diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 08beaf7d2599..e2f1782e5d42 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -142,6 +142,7 @@ BITCOIN_TESTS =\
   test/llmq_snapshot_tests.cpp \
   test/llmq_utils_tests.cpp \
   test/logging_tests.cpp \
+  test/masternode_payments_tests.cpp \
   test/dbwrapper_tests.cpp \
   test/validation_tests.cpp \
   test/mempool_tests.cpp \
diff --git a/src/masternode/payments.cpp b/src/masternode/payments.cpp
index f3f090e80942..030b67a64a30 100644
--- a/src/masternode/payments.cpp
+++ b/src/masternode/payments.cpp
@@ -21,6 +21,36 @@
 #include <ranges>
 #include <string>
 
+int FindUnmatchedMasternodePayment(const std::vector<CTxOut>& expected,
+                                   const std::vector<CTxOut>& actual,
+                                   bool strict_multiplicity)
+{
+    if (!strict_multiplicity) {
+        for (size_t i = 0; i < expected.size(); ++i) {
+            const auto& txout = expected[i];
+            if (!std::ranges::any_of(actual, [&txout](const auto& txout2) { return txout == txout2; })) {
+                return static_cast<int>(i);
+            }
+        }
+        return -1;
+    }
+
+    std::vector<bool> consumed(actual.size(), false);
+    for (size_t i = 0; i < expected.size(); ++i) {
+        const auto& txout = expected[i];
+        bool found = false;
+        for (size_t j = 0; j < actual.size(); ++j) {
+            if (!consumed[j] && actual[j] == txout) {
+                consumed[j] = true;
+                found = true;
+                break;
+            }
+        }
+        if (!found) return static_cast<int>(i);
+    }
+    return -1;
+}
+
 CAmount PlatformShare(const CAmount reward)
 {
     const CAmount platformReward = reward * 375 / 1000;
@@ -184,7 +214,7 @@ CAmount GetMasternodePayment(int nHeight, CAmount blockValue, const Consensus::P
 }
 
 [[nodiscard]] bool CMNPaymentsProcessor::IsTransactionValid(const CTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy,
-                                                            const CAmount feeReward, MnRewardEra era)
+                                                            const CAmount feeReward, MnRewardEra era, bool strict_multiplicity)
 {
     const int nBlockHeight = pindexPrev  == nullptr ? 0 : pindexPrev->nHeight + 1;
     if (!DeploymentDIP0003Enforced(nBlockHeight, m_consensus_params)) {
@@ -198,19 +228,22 @@ CAmount GetMasternodePayment(int nHeight, CAmount blockValue, const Consensus::P
         return true;
     }
 
-    for (const auto& txout : voutMasternodePayments) {
-        bool found = std::ranges::any_of(txNew.vout, [&txout](const auto& txout2) { return txout == txout2; });
-        if (!found) {
-            std::string str_payout;
-            if (CTxDestination dest; ExtractDestination(txout.scriptPubKey, dest)) {
-                str_payout = "address=" + EncodeDestination(dest);
-            } else {
-                str_payout = "scriptPubKey=" + HexStr(txout.scriptPubKey);
-            }
-            LogPrintf("CMNPaymentsProcessor::%s -- ERROR! Failed to find expected payee %s amount=%lld height=%d\n",
-                      __func__, str_payout, txout.nValue, nBlockHeight);
-            return false;
+    // With strict multiplicity (v24 active, computed by the caller) each expected payment must be
+    // matched by a distinct coinbase output: duplicate expected outputs require duplicate coinbase
+    // outputs. Pre-v24 retains the legacy existence-only check to avoid tightening historical
+    // validation.
+    const int unmatched_idx = FindUnmatchedMasternodePayment(voutMasternodePayments, txNew.vout, strict_multiplicity);
+    if (unmatched_idx >= 0) {
+        const auto& txout = voutMasternodePayments[unmatched_idx];
+        std::string str_payout;
+        if (CTxDestination dest; ExtractDestination(txout.scriptPubKey, dest)) {
+            str_payout = "address=" + EncodeDestination(dest);
+        } else {
+            str_payout = "scriptPubKey=" + HexStr(txout.scriptPubKey);
         }
+        LogPrintf("CMNPaymentsProcessor::%s -- ERROR! Failed to find expected payee %s amount=%lld height=%d\n",
+                  __func__, str_payout, txout.nValue, nBlockHeight);
+        return false;
     }
     return true;
 }
@@ -339,12 +372,12 @@ bool CMNPaymentsProcessor::IsBlockValueValid(const CChain& active_chain, const C
     return true;
 }
 
-bool CMNPaymentsProcessor::IsBlockPayeeValid(const CChain& active_chain, const CTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward, MnRewardEra era, SuperBlockCheckType check_superblock)
+bool CMNPaymentsProcessor::IsBlockPayeeValid(const CChain& active_chain, const CTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward, MnRewardEra era, bool strict_multiplicity, SuperBlockCheckType check_superblock)
 {
     const int nBlockHeight = pindexPrev  == nullptr ? 0 : pindexPrev->nHeight + 1;
 
     // Check for correct masternode payment
-    if (IsTransactionValid(txNew, pindexPrev, blockSubsidy, feeReward, era)) {
+    if (IsTransactionValid(txNew, pindexPrev, blockSubsidy, feeReward, era, strict_multiplicity)) {
         LogPrint(BCLog::MNPAYMENTS, "CMNPaymentsProcessor::%s -- Valid masternode payment at height %d: %s", __func__, nBlockHeight, txNew.ToString()); /* Continued */
     } else {
         LogPrintf("CMNPaymentsProcessor::%s -- ERROR! Invalid masternode payment detected at height %d: %s", __func__, nBlockHeight, txNew.ToString()); /* Continued */
diff --git a/src/masternode/payments.h b/src/masternode/payments.h
index c1c06079aefa..661f8488a7a8 100644
--- a/src/masternode/payments.h
+++ b/src/masternode/payments.h
@@ -17,6 +17,25 @@ class CDeterministicMNManager;
 class CTransaction;
 class CTxOut;
 
+/**
+ * Match the list of expected masternode payment outputs against the coinbase
+ * outputs.
+ *
+ * When @p strict_multiplicity is true, every expected output must be matched
+ * by a distinct actual output (multiplicity-correct matching): two identical
+ * expected outputs require two identical actual outputs.
+ *
+ * When false, the legacy behaviour is used where each expected output only
+ * has to appear at least once in the actual outputs. This is preserved for
+ * pre-v24 historical validation.
+ *
+ * @return -1 if every expected output is matched, otherwise the index in
+ * @p expected of the first output that could not be matched.
+ */
+int FindUnmatchedMasternodePayment(const std::vector<CTxOut>& expected,
+                                   const std::vector<CTxOut>& actual,
+                                   bool strict_multiplicity);
+
 struct CMutableTransaction;
 
 namespace governance {
@@ -65,7 +84,7 @@ class CMNPaymentsProcessor
     [[nodiscard]] bool GetMasternodeTxOuts(const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward,
                                       MnRewardEra era, std::vector<CTxOut>& voutMasternodePaymentsRet);
     [[nodiscard]] bool IsTransactionValid(const CTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy,
-                                          const CAmount feeReward, MnRewardEra era);
+                                          const CAmount feeReward, MnRewardEra era, bool strict_multiplicity);
     [[nodiscard]] bool IsOldBudgetBlockValueValid(const CBlock& block, const int nBlockHeight, const CAmount blockReward, std::string& strErrorRet);
 
 public:
@@ -78,7 +97,7 @@ class CMNPaymentsProcessor
     }
 
     bool IsBlockValueValid(const CChain& active_chain, const CBlock& block, const CBlockIndex* pindexPrev, const CAmount blockReward, std::string& strErrorRet, SuperBlockCheckType check_superblock);
-    bool IsBlockPayeeValid(const CChain& active_chain, const CTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward, MnRewardEra era, SuperBlockCheckType check_superblock);
+    bool IsBlockPayeeValid(const CChain& active_chain, const CTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward, MnRewardEra era, bool strict_multiplicity, SuperBlockCheckType check_superblock);
     void FillBlockPayments(CMutableTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward,
                            MnRewardEra era, std::vector<CTxOut>& voutMasternodePaymentsRet, std::vector<CTxOut>& voutSuperblockPaymentsRet);
 };
diff --git a/src/test/evo_deterministicmns_tests.cpp b/src/test/evo_deterministicmns_tests.cpp
index e8c40cf17d53..fa821d8a5674 100644
--- a/src/test/evo_deterministicmns_tests.cpp
+++ b/src/test/evo_deterministicmns_tests.cpp
@@ -6,6 +6,7 @@
 
 #include <chainparams.h>
 #include <clientversion.h>
+#include <consensus/merkle.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
 #include <evo/deterministicmns.h>
@@ -19,6 +20,7 @@
 #include <netbase.h>
 #include <node/transaction.h>
 #include <policy/policy.h>
+#include <pow.h>
 #include <script/interpreter.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
@@ -30,6 +32,7 @@
 
 #include <boost/test/unit_test.hpp>
 
+#include <optional>
 #include <vector>
 
 using node::GetTransaction;
@@ -669,6 +672,211 @@ void FuncProUpRegTxV2CannotBypassV4PayoutCollateralReuse(TestChainSetup& setup)
     BOOST_CHECK_EQUAL(val_state.GetRejectReason(), "bad-protx-payee-reuse");
 }
 
+// Coinbase validation matches each expected masternode payment against a DISTINCT coinbase output
+// only after v24. This exercises the exact activation boundary with a SINGLE masternode whose
+// owner payout and operator payout resolve to the same script AND amount (an even 50% operator
+// reward), so the coinbase carries two identical outputs. The "merge cheat" folds those two
+// identical outputs into one, redirecting the freed value to a miner output so the total coinbase
+// value is unchanged; this underpays the masternode.
+//
+//   Pre-v24:  existence-only matching ACCEPTS the merge cheat.
+//   Post-v24: strict multiplicity matching REJECTS it (and the faithful block connects).
+//
+// The duplicate is NOT a multi-payout (v4) phenomenon: multi-payout owner shares are forced to
+// distinct scripts (bad-protx-payee-dup) and can never collide. It is a plain owner-payout ==
+// operator-payout script collision, which every ProTx version supports -- here a v2 (BasicBLS)
+// MN, the max version eligible while v24 is still pending, kept across the boundary.
+void FuncMNPaymentMultiplicityV24Boundary(TestChainSetup& setup)
+{
+    auto& chainman = *Assert(setup.m_node.chainman.get());
+    auto& dmnman = *Assert(setup.m_node.dmnman);
+    const CScript coinbase_pk = GetScriptForRawPubKey(setup.coinbaseKey.GetPubKey());
+    const auto& consensus = chainman.GetConsensus();
+
+    // Start in the pre-v24 window: v19 active (basic BLS scheme) so we can register a v2 MN, but
+    // v24 -- and thus strict multiplicity matching -- not yet active.
+    BOOST_REQUIRE(DeploymentActiveAfter(chainman.ActiveChain().Tip(), consensus, Consensus::DEPLOYMENT_V19));
+    BOOST_REQUIRE(!DeploymentActiveAfter(chainman.ActiveChain().Tip(), chainman, Consensus::DEPLOYMENT_V24));
+    BOOST_REQUIRE(!bls::bls_legacy_scheme.load());
+
+    auto utxos = BuildSimpleUtxoMap(setup.m_coinbase_txns);
+
+    // A single script that BOTH an owner payout and the operator payout will point at.
+    CKey payout_key;
+    payout_key.MakeNewKey(true);
+    const CScript shared_script = GetScriptForDestination(PKHash(payout_key.GetPubKey()));
+
+    CKey owner_key;
+    CKey collateral_key;
+    CBLSSecretKey operator_key;
+    owner_key.MakeNewKey(true);
+    collateral_key.MakeNewKey(true);
+    operator_key.MakeNewKey();
+    const auto script_collateral = GetScriptForDestination(PKHash(collateral_key.GetPubKey()));
+
+    // Fund the collateral.
+    CMutableTransaction tx_collateral;
+    FundTransaction(chainman.ActiveChain(), tx_collateral, utxos, script_collateral, dmn_types::Regular.collat_amount,
+                    setup.coinbaseKey);
+    SignTransaction(*(setup.m_node.mempool), tx_collateral, setup.coinbaseKey);
+    setup.CreateAndProcessBlock({tx_collateral}, coinbase_pk);
+    dmnman.UpdatedBlockTip(chainman.ActiveChain().Tip());
+
+    // Register a plain v2 (BasicBLS) MN -- deliberately NOT multi-payout, and the max version
+    // eligible while v24 is pending -- with a single legacy owner payout -> shared_script and a
+    // 50% operator reward, so the owner share and the operator share are equal whenever the
+    // masternode reward is even.
+    CProRegTx pro_reg;
+    pro_reg.nVersion = ProTxVersion::BasicBLS;
+    pro_reg.netInfo = NetInfoInterface::MakeNetInfo(pro_reg.nVersion);
+    // Legacy MnNetInfo (v2) on regtest must not use the mainnet port; a small port works.
+    BOOST_CHECK_EQUAL(pro_reg.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:1"), NetInfoStatus::Success);
+    pro_reg.keyIDOwner = owner_key.GetPubKey().GetID();
+    pro_reg.pubKeyOperator.Set(operator_key.GetPublicKey(), bls::bls_legacy_scheme.load());
+    pro_reg.keyIDVoting = owner_key.GetPubKey().GetID();
+    pro_reg.nOperatorReward = 5000; // 50%
+    pro_reg.scriptPayout = shared_script;
+    for (size_t i = 0; i < tx_collateral.vout.size(); ++i) {
+        if (tx_collateral.vout[i].nValue == dmn_types::Regular.collat_amount) {
+            pro_reg.collateralOutpoint = COutPoint(tx_collateral.GetHash(), i);
+            break;
+        }
+    }
+
+    CMutableTransaction tx_reg;
+    tx_reg.nVersion = 3;
+    tx_reg.nType = TRANSACTION_PROVIDER_REGISTER;
+    FundTransaction(chainman.ActiveChain(), tx_reg, utxos, GetScriptForDestination(PKHash(setup.coinbaseKey.GetPubKey())),
+                    1 * COIN, setup.coinbaseKey);
+    pro_reg.inputsHash = CalcTxInputsHash(CTransaction(tx_reg));
+    CMessageSigner::SignMessage(pro_reg.MakeSignString(), pro_reg.vchSig, collateral_key);
+    SetTxPayload(tx_reg, pro_reg);
+    SignTransaction(*(setup.m_node.mempool), tx_reg, setup.coinbaseKey);
+    const auto proTxHash = tx_reg.GetHash();
+    setup.CreateAndProcessBlock({tx_reg}, coinbase_pk);
+    dmnman.UpdatedBlockTip(chainman.ActiveChain().Tip());
+
+    auto dmn = dmnman.GetListAtChainTip().GetMN(proTxHash);
+    BOOST_REQUIRE(dmn);
+    BOOST_CHECK_EQUAL(dmn->pdmnState->nVersion, ProTxVersion::BasicBLS);
+
+    // Point the operator payout at the same script as the owner payout. Nothing checks the
+    // operator payout script against the owner payout script, in any version, so this collision
+    // is accepted.
+    CProUpServTx pro_ups;
+    pro_ups.nVersion = ProTxVersion::BasicBLS;
+    pro_ups.proTxHash = proTxHash;
+    pro_ups.netInfo = NetInfoInterface::MakeNetInfo(pro_ups.nVersion);
+    BOOST_CHECK_EQUAL(pro_ups.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:1"), NetInfoStatus::Success);
+    pro_ups.scriptOperatorPayout = shared_script;
+
+    CMutableTransaction tx_ups;
+    tx_ups.nVersion = 3;
+    tx_ups.nType = TRANSACTION_PROVIDER_UPDATE_SERVICE;
+    FundTransaction(chainman.ActiveChain(), tx_ups, utxos, GetScriptForDestination(PKHash(setup.coinbaseKey.GetPubKey())),
+                    1 * COIN, setup.coinbaseKey);
+    pro_ups.inputsHash = CalcTxInputsHash(CTransaction(tx_ups));
+    pro_ups.sig = operator_key.Sign(::SerializeHash(pro_ups), bls::bls_legacy_scheme);
+    SetTxPayload(tx_ups, pro_ups);
+    SignTransaction(*(setup.m_node.mempool), tx_ups, setup.coinbaseKey);
+    setup.CreateAndProcessBlock({tx_ups}, coinbase_pk);
+    dmnman.UpdatedBlockTip(chainman.ActiveChain().Tip());
+    BOOST_REQUIRE(dmnman.GetListAtChainTip().GetMN(proTxHash)->pdmnState->scriptOperatorPayout == shared_script);
+
+    // Two identical coinbase outputs paying shared_script (the owner/operator collision).
+    auto find_duplicate = [&](const CBlock& b) -> std::optional<CTxOut> {
+        const auto& vout = b.vtx[0]->vout;
+        for (size_t i = 0; i < vout.size(); ++i) {
+            if (vout[i].scriptPubKey != shared_script) continue;
+            for (size_t j = i + 1; j < vout.size(); ++j) {
+                if (vout[j] == vout[i]) return vout[i];
+            }
+        }
+        return std::nullopt;
+    };
+
+    // Mine until a block's (pre-operator) masternode reward is even: only then does the 50%
+    // operator share equal the single owner share, so the owner and operator outputs -- both
+    // paying shared_script -- collide into two identical coinbase outputs. The reward is constant
+    // within a subsidy/reallocation epoch, so this can take up to a full epoch; intermediate
+    // blocks are processed to advance the chain.
+    auto mine_until_duplicate = [&]() -> std::pair<CBlock, CTxOut> {
+        for (int i = 0; i < 2000; ++i) {
+            CBlock good = setup.CreateBlock({}, coinbase_pk, chainman.ActiveChainstate());
+            if (auto dup = find_duplicate(good)) return {good, *dup};
+            BOOST_REQUIRE(chainman.ProcessNewBlock(std::make_shared<CBlock>(good), /*force_processing=*/true, nullptr));
+            dmnman.UpdatedBlockTip(chainman.ActiveChain().Tip());
+        }
+        BOOST_REQUIRE_MESSAGE(false, "expected owner/operator collision to yield a duplicate coinbase output");
+        return {}; // unreachable, BOOST_REQUIRE above aborts the test
+    };
+
+    // Build the "merge cheat" sibling of `good`: drop one of the two identical outputs and fold
+    // its value into a non-masternode (miner) output. Total coinbase value is unchanged (so
+    // IsBlockValueValid still passes), but only ONE distinct output now pays shared_script.
+    auto build_merge_cheat = [&](const CBlock& good, const CTxOut& dup) -> CBlock {
+        CBlock merged = good;
+        CMutableTransaction cb(*merged.vtx[0]);
+        bool kept_first = false;
+        for (auto it = cb.vout.begin(); it != cb.vout.end();) {
+            if (*it == dup && kept_first) {
+                it = cb.vout.erase(it);
+            } else {
+                if (*it == dup) kept_first = true;
+                ++it;
+            }
+        }
+        bool redirected = false;
+        for (auto& o : cb.vout) {
+            if (o.scriptPubKey != shared_script && !o.scriptPubKey.IsUnspendable()) {
+                o.nValue += dup.nValue;
+                redirected = true;
+                break;
+            }
+        }
+        BOOST_REQUIRE(redirected);
+        merged.vtx[0] = MakeTransactionRef(std::move(cb));
+        merged.hashMerkleRoot = BlockMerkleRoot(merged);
+        merged.nNonce = 0;
+        while (!CheckProofOfWork(merged.GetHash(), merged.nBits, consensus)) ++merged.nNonce;
+        return merged;
+    };
+
+    // ---- Pre-v24: legacy existence-only matching ACCEPTS the merge cheat (masternode underpaid).
+    {
+        const auto [good, dup] = mine_until_duplicate();
+        // The collision must be reached while v24 is still pending, otherwise this phase would be
+        // testing post-v24 behaviour by accident.
+        BOOST_REQUIRE(!DeploymentActiveAfter(chainman.ActiveChain().Tip(), chainman, Consensus::DEPLOYMENT_V24));
+        const CBlock merged = build_merge_cheat(good, dup);
+        BOOST_REQUIRE(chainman.ProcessNewBlock(std::make_shared<CBlock>(merged), /*force_processing=*/true, nullptr));
+        BOOST_CHECK_EQUAL(chainman.ActiveChain().Tip()->GetBlockHash(), merged.GetHash());
+        dmnman.UpdatedBlockTip(chainman.ActiveChain().Tip());
+    }
+
+    // ---- Mine across v24 activation (the same v2 MN is kept; its collision is version-independent).
+    for (int i = 0; i < 2000 && !DeploymentActiveAfter(chainman.ActiveChain().Tip(), chainman, Consensus::DEPLOYMENT_V24); ++i) {
+        setup.CreateAndProcessBlock({}, coinbase_pk);
+        dmnman.UpdatedBlockTip(chainman.ActiveChain().Tip());
+    }
+    BOOST_REQUIRE(DeploymentActiveAfter(chainman.ActiveChain().Tip(), chainman, Consensus::DEPLOYMENT_V24));
+
+    // ---- Post-v24: strict multiplicity matching REJECTS the same merge (two expected outputs, one
+    // distinct actual). Rejection is observed as the tip not advancing.
+    {
+        const auto [good, dup] = mine_until_duplicate();
+        const CBlock merged = build_merge_cheat(good, dup);
+        const uint256 tip_before = chainman.ActiveChain().Tip()->GetBlockHash();
+        chainman.ProcessNewBlock(std::make_shared<CBlock>(merged), /*force_processing=*/true, nullptr);
+        BOOST_CHECK(chainman.ActiveChain().Tip()->GetBlockHash() == tip_before);
+        BOOST_CHECK(chainman.ActiveChain().Tip()->GetBlockHash() != merged.GetHash());
+
+        // The faithful block (both identical outputs present) connects.
+        BOOST_REQUIRE(chainman.ProcessNewBlock(std::make_shared<CBlock>(good), /*force_processing=*/true, nullptr));
+        BOOST_CHECK_EQUAL(chainman.ActiveChain().Tip()->GetBlockHash(), good.GetHash());
+    }
+}
+
 static std::shared_ptr<NetInfoInterface> DeserializeCoreP2PExtNetInfo(const std::vector<NetInfoEntry>& entries)
 {
     // Hand-roll ExtNetInfo's serialization (version byte followed by a map of purpose to entries)
@@ -1327,6 +1535,31 @@ struct TestChainV24SignalBeforeV19Setup : public TestChainSetup {
     }
 };
 
+// v19/v20/mn_rr active at height 500, with v24 signalled but still PENDING (not yet locked in).
+// The 500-block window means v24 locks in well after v19, so this fixture stops in the window
+// where basic-BLS (v2) registrations are valid but strict multiplicity matching is off, letting
+// a single test cross the v24 activation boundary.
+struct TestChainV24PendingSetup : public TestChainSetup {
+    TestChainV24PendingSetup() :
+        TestChainSetup(494, CBaseChainParams::REGTEST,
+                       {"-testactivationheight=v19@500", "-testactivationheight=v20@500",
+                        "-testactivationheight=mn_rr@500",
+                        "-vbparams=v24:0:9999999999:0:500:400:300:5:0"})
+    {
+        const CScript coinbase_pk = GetScriptForRawPubKey(coinbaseKey.GetPubKey());
+        auto& chainman = *Assert(m_node.chainman);
+        auto& dmnman = *Assert(m_node.dmnman);
+        // Mine just enough to activate v19/v20/mn_rr (height 500) while keeping v24 pending.
+        for (int i = 0; i < 20 && !DeploymentActiveAfter(chainman.ActiveChain().Tip(), chainman.GetConsensus(), Consensus::DEPLOYMENT_V19); ++i) {
+            CreateAndProcessBlock({}, coinbase_pk);
+            dmnman.UpdatedBlockTip(chainman.ActiveChain().Tip());
+        }
+        assert(DeploymentActiveAfter(chainman.ActiveChain().Tip(), chainman.GetConsensus(), Consensus::DEPLOYMENT_V19));
+        assert(!DeploymentActiveAfter(chainman.ActiveChain().Tip(), chainman, Consensus::DEPLOYMENT_V24));
+        assert(!bls::bls_legacy_scheme.load());
+    }
+};
+
 // DIP3 can only be activated with legacy scheme (v19 is activated later)
 BOOST_AUTO_TEST_CASE(dip3_activation_legacy)
 {
@@ -1365,6 +1598,12 @@ BOOST_AUTO_TEST_CASE(proregtx_rejects_invalid_deserialized_extnetinfo)
     FuncProRegTxRejectsInvalidDeserializedExtNetInfo(setup);
 }
 
+BOOST_AUTO_TEST_CASE(mn_payment_multiplicity_v24_boundary)
+{
+    TestChainV24PendingSetup setup;
+    FuncMNPaymentMultiplicityV24Boundary(setup);
+}
+
 BOOST_AUTO_TEST_CASE(dip3_protx_legacy)
 {
     TestChainDIP3Setup setup;
diff --git a/src/test/masternode_payments_tests.cpp b/src/test/masternode_payments_tests.cpp
new file mode 100644
index 000000000000..d85d51bae606
--- /dev/null
+++ b/src/test/masternode_payments_tests.cpp
@@ -0,0 +1,88 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <masternode/payments.h>
+
+#include <primitives/transaction.h>
+#include <script/script.h>
+
+#include <vector>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_SUITE(masternode_payments_tests)
+
+namespace {
+CTxOut MakeOut(CAmount value, uint8_t script_byte)
+{
+    CScript script;
+    script << OP_RETURN << std::vector<uint8_t>{script_byte};
+    return CTxOut{value, script};
+}
+} // namespace
+
+BOOST_AUTO_TEST_CASE(strict_matches_simple)
+{
+    const std::vector<CTxOut> expected{MakeOut(100, 0x01), MakeOut(200, 0x02)};
+    const std::vector<CTxOut> actual{MakeOut(100, 0x01), MakeOut(200, 0x02), MakeOut(50, 0x03)};
+
+    BOOST_CHECK_EQUAL(FindUnmatchedMasternodePayment(expected, actual, /*strict_multiplicity=*/true), -1);
+    BOOST_CHECK_EQUAL(FindUnmatchedMasternodePayment(expected, actual, /*strict_multiplicity=*/false), -1);
+}
+
+BOOST_AUTO_TEST_CASE(strict_missing_output_fails)
+{
+    const std::vector<CTxOut> expected{MakeOut(100, 0x01), MakeOut(200, 0x02)};
+    const std::vector<CTxOut> actual{MakeOut(100, 0x01)};
+
+    BOOST_CHECK_EQUAL(FindUnmatchedMasternodePayment(expected, actual, /*strict_multiplicity=*/true), 1);
+    BOOST_CHECK_EQUAL(FindUnmatchedMasternodePayment(expected, actual, /*strict_multiplicity=*/false), 1);
+}
+
+// Regression: with two identical expected masternode payments, strict multiplicity
+// matching must require two identical coinbase outputs. A single output should
+// NOT satisfy both expected outputs (which was the bug pre-v24).
+BOOST_AUTO_TEST_CASE(strict_duplicate_expected_requires_duplicate_actual)
+{
+    const std::vector<CTxOut> expected{MakeOut(100, 0x01), MakeOut(100, 0x01)};
+
+    // Only one matching actual output: strict must reject, legacy must accept.
+    const std::vector<CTxOut> actual_one{MakeOut(100, 0x01), MakeOut(50, 0x02)};
+    BOOST_CHECK_EQUAL(FindUnmatchedMasternodePayment(expected, actual_one, /*strict_multiplicity=*/true), 1);
+    BOOST_CHECK_EQUAL(FindUnmatchedMasternodePayment(expected, actual_one, /*strict_multiplicity=*/false), -1);
+
+    // Two matching actual outputs: both modes accept.
+    const std::vector<CTxOut> actual_two{MakeOut(100, 0x01), MakeOut(100, 0x01), MakeOut(50, 0x02)};
+    BOOST_CHECK_EQUAL(FindUnmatchedMasternodePayment(expected, actual_two, /*strict_multiplicity=*/true), -1);
+    BOOST_CHECK_EQUAL(FindUnmatchedMasternodePayment(expected, actual_two, /*strict_multiplicity=*/false), -1);
+}
+
+// Pre-v24 path retains the old existence-only behaviour: a single actual output
+// can satisfy any number of identical expected outputs.
+BOOST_AUTO_TEST_CASE(legacy_existence_only_matches_duplicates)
+{
+    const std::vector<CTxOut> expected{MakeOut(100, 0x01), MakeOut(100, 0x01), MakeOut(100, 0x01)};
+    const std::vector<CTxOut> actual{MakeOut(100, 0x01)};
+
+    BOOST_CHECK_EQUAL(FindUnmatchedMasternodePayment(expected, actual, /*strict_multiplicity=*/false), -1);
+    BOOST_CHECK_EQUAL(FindUnmatchedMasternodePayment(expected, actual, /*strict_multiplicity=*/true), 1);
+}
+
+BOOST_AUTO_TEST_CASE(empty_expected_is_trivially_matched)
+{
+    const std::vector<CTxOut> expected{};
+    const std::vector<CTxOut> actual{MakeOut(100, 0x01)};
+    BOOST_CHECK_EQUAL(FindUnmatchedMasternodePayment(expected, actual, /*strict_multiplicity=*/true), -1);
+    BOOST_CHECK_EQUAL(FindUnmatchedMasternodePayment(expected, actual, /*strict_multiplicity=*/false), -1);
+}
+
+BOOST_AUTO_TEST_CASE(strict_amount_must_match_exactly)
+{
+    const std::vector<CTxOut> expected{MakeOut(100, 0x01)};
+    const std::vector<CTxOut> actual{MakeOut(99, 0x01)};
+    BOOST_CHECK_EQUAL(FindUnmatchedMasternodePayment(expected, actual, /*strict_multiplicity=*/true), 0);
+    BOOST_CHECK_EQUAL(FindUnmatchedMasternodePayment(expected, actual, /*strict_multiplicity=*/false), 0);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/validation.cpp b/src/validation.cpp
index 2b1d6665ffed..012783385685 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -2450,10 +2450,10 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
     int64_t nTime5_2 = GetTimeMicros(); nTimeSubsidy += nTime5_2 - nTime5_1;
     LogPrint(BCLog::BENCHMARK, "      - GetBlockSubsidy: %.2fms [%.2fs (%.2fms/blk)]\n", MILLI * (nTime5_2 - nTime5_1), nTimeSubsidy * MICRO, nTimeSubsidy * MILLI / nBlocksTotal);
 
+    const bool is_v24_active{DeploymentActiveAfter(pindex->pprev, m_chainman, Consensus::DEPLOYMENT_V24)};
     const SuperBlockCheckType check_superblock = !m_chain_helper->IsSuperblockValidationRequired(pindex)
         ? SuperBlockCheckType::NoCheck
-        : DeploymentActiveAfter(pindex->pprev, m_chainman, Consensus::DEPLOYMENT_V24) ?
-            SuperBlockCheckType::DisallowDuplicates : SuperBlockCheckType::AllowDuplicates;
+        : is_v24_active ? SuperBlockCheckType::DisallowDuplicates : SuperBlockCheckType::AllowDuplicates;
 
 
     if (!m_chain_helper->mn_payments->IsBlockValueValid(m_chainman.ActiveChain(), block, pindex->pprev, blockSubsidy + feeReward, strError, check_superblock)) {
@@ -2466,7 +2466,7 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
     LogPrint(BCLog::BENCHMARK, "      - IsBlockValueValid: %.2fms [%.2fs (%.2fms/blk)]\n", MILLI * (nTime5_3 - nTime5_2), nTimeValueValid * MICRO, nTimeValueValid * MILLI / nBlocksTotal);
 
     const MnRewardEra mn_reward_era{GetMnRewardEraAfter(pindex->pprev, m_chainman)};
-    if (!m_chain_helper->mn_payments->IsBlockPayeeValid(m_chainman.ActiveChain(), *block.vtx[0], pindex->pprev, blockSubsidy, feeReward, mn_reward_era, check_superblock)) {
+    if (!m_chain_helper->mn_payments->IsBlockPayeeValid(m_chainman.ActiveChain(), *block.vtx[0], pindex->pprev, blockSubsidy, feeReward, mn_reward_era, is_v24_active, check_superblock)) {
         // NOTE: Do not punish, the node might be missing governance data
         LogPrintf("ERROR: ConnectBlock(DASH): couldn't find masternode or superblock payments\n");
         return state.Invalid(BlockValidationResult::BLOCK_RESULT_UNSET, "bad-cb-payee");
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 7b49af36a695..b259b0793f40 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -64,6 +64,7 @@ src/test/dip0020opcodes_tests.cpp
 src/test/dynamic_activation*.cpp
 src/test/evo*.cpp
 src/test/llmq*.cpp
+src/test/masternode_payments_tests.cpp
 src/test/util/llmq_tests.h
 src/test/governance*.cpp
 src/unordered_lru_cache.h