The most natural option would be the following:
- Let the parties run threshold decryption to obtain additive shares of the plaintext $m_1$
- Run an MPC protocol that takes as input shares of $m_1$ and outputs shares of the equality test $[m_1 = _? 0]$. For example, in the two-party setting, you can use my paper (which is more or less still the state of the art, depending on your exact context -- size of $m_1$, time for preprocessing, number of executions, etc). There are also solutions in the $n$-party setting, the introduction of my paper should indicate what was the state of the art in 2016, but I'm not sure what would be the best solution now.
- Convert back the shares of the output into an encryption of the output, the usual way: everyone encrypts their shares, broadcasts the ciphertexts, and the encrypted shares are homomorphically summed to recover the encrypted result.
In the two-party setting, there are very efficient equality tests (the one from my paper, but also others which are better if preprocessing is cheap, like this one), so this should overall work very well. I expect it to be more costly in the $n$-party setting with $n>2$, but you should search a bit the literature to know for sure!
EDIT for clarification:
The paper just assume that two parties have $x$ and $y$, and want to test whether $x = y$. If you have a threshold encryption scheme where the plaintext space is $\mathbb{Z}_n$, after threshold decryption, the parties have respective shares $m_1, m_2 \in \mathbb{Z}_n$ (seen as integers between $0$ and $n-1$) of the plaintext $m$. Then, testing whether $m=0 \bmod n$ is equivalent to testing whether $m_1 + m_2 = n$, i.e. testing whether $m_1 = n-m_2$. Hence, $P_1$ sets $x=m_1$, $P_2$ sets $y = n-m*2$, and the two parties run an equality test, as in my paper.
In the end, the parties have shares mod 2 of the result: that is, $b_1, b_2$ such that $b_1 \oplus b_2 = [m =_? 0]$, where $\oplus$ is the XOR. Then, the parties can easily construct an encryption of $[m =_? 0]$ with their additively homomorphic encryption scheme, using the identity $b_1 \oplus b_2 = b_1 + b_2 - 2b_1b_2$: $P_1$ sends a random encryption of $b_1$, and $P_2$ homomorphically compute an encryption of $b_1(1-2b_2) + b_2 = b_1 \oplus b_2 = [m=_? 0]$ (and rerandomizes it).