diff --git a/src/Makefile.am b/src/Makefile.am
index 5137d940baef..8a4ade852050 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -931,6 +931,7 @@ libbitcoin_common_a_SOURCES = \
   deploymentinfo.cpp \
   evo/core_write.cpp \
   evo/netinfo.cpp \
+  evo/providertx_util.cpp \
   external_signer.cpp \
   governance/common.cpp \
   governance/core_write.cpp \
@@ -1200,6 +1201,7 @@ dash_chainstate_SOURCES = \
   evo/netinfo.cpp \
   evo/mnhftx.cpp \
   evo/providertx.cpp \
+  evo/providertx_util.cpp \
   evo/simplifiedmns.cpp \
   evo/smldiff.cpp \
   evo/specialtx.cpp \
diff --git a/src/common/bloom.cpp b/src/common/bloom.cpp
index 9d39f35c12e3..4b0c4c334f19 100644
--- a/src/common/bloom.cpp
+++ b/src/common/bloom.cpp
@@ -132,10 +132,13 @@ bool CBloomFilter::CheckSpecialTransactionMatchesAndUpdate(const CTransaction &t
     switch(tx.nType) {
     case(TRANSACTION_PROVIDER_REGISTER): {
         if (const auto opt_proTx = GetTxPayload<CProRegTx>(tx)) {
+            const auto owner_payouts = GetOwnerPayouts(opt_proTx->nVersion, opt_proTx->scriptPayout, opt_proTx->payouts);
+            const bool found_payout = std::any_of(owner_payouts.begin(), owner_payouts.end(),
+                                                  [&](const auto& payout) { return CheckScript(payout.scriptPayout); });
             if(contains(opt_proTx->collateralOutpoint) ||
                     contains(opt_proTx->keyIDOwner) ||
                     contains(opt_proTx->keyIDVoting) ||
-                    CheckScript(opt_proTx->scriptPayout)) {
+                    found_payout) {
                 if ((nFlags & BLOOM_UPDATE_MASK) == BLOOM_UPDATE_ALL)
                     insert(tx.GetHash());
                 return true;
@@ -160,8 +163,11 @@ bool CBloomFilter::CheckSpecialTransactionMatchesAndUpdate(const CTransaction &t
         if (const auto opt_proTx = GetTxPayload<CProUpRegTx>(tx)) {
             if(contains(opt_proTx->proTxHash))
                 return true;
+            const auto owner_payouts = GetOwnerPayouts(opt_proTx->nVersion, opt_proTx->scriptPayout, opt_proTx->payouts);
+            const bool found_payout = std::any_of(owner_payouts.begin(), owner_payouts.end(),
+                                                  [&](const auto& payout) { return CheckScript(payout.scriptPayout); });
             if(contains(opt_proTx->keyIDVoting) ||
-                    CheckScript(opt_proTx->scriptPayout)) {
+                    found_payout) {
                 if ((nFlags & BLOOM_UPDATE_MASK) == BLOOM_UPDATE_ALL)
                     insert(opt_proTx->proTxHash);
                 return true;
diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index 1ccfc998840b..3fc879c6d2cd 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -53,6 +53,16 @@ const std::map<std::string, RPCResult> RPCRESULT_MAP{{
     RESULT_MAP_ENTRY("outpoint", RPCResult::Type::STR_HEX,"The outpoint of the masternode"),
     RESULT_MAP_ENTRY("ownerAddress", RPCResult::Type::STR, "Dash address used for payee updates and proposal voting"),
     RESULT_MAP_ENTRY("payoutAddress", RPCResult::Type::STR, "Dash address used for masternode reward payments"),
+    {"payouts",
+        {RPCResult::Type::ARR, "payouts", "Owner masternode reward payout shares",
+    {
+        {RPCResult::Type::OBJ, "", "",
+        {
+            {RPCResult::Type::STR, "address", "Dash address used for this owner payout"},
+            {RPCResult::Type::STR_HEX, "script", "Owner payout scriptPubKey"},
+            {RPCResult::Type::NUM, "reward", "Owner payout share in basis points"},
+        }},
+    }}},
     RESULT_MAP_ENTRY("platformHTTPPort", RPCResult::Type::NUM, "TCP port of Platform HTTP API (DEPRECATED, returned only if config option -deprecatedrpc=service is passed)"),
     RESULT_MAP_ENTRY("platformNodeID", RPCResult::Type::STR_HEX, "Node ID derived from P2P public key for Platform P2P"),
     RESULT_MAP_ENTRY("platformP2PPort", RPCResult::Type::NUM, "TCP port of Platform P2P (DEPRECATED, returned only if config option -deprecatedrpc=service is passed)"),
@@ -212,6 +222,7 @@ RPCResult CDeterministicMNState::GetJsonHelp(const std::string& key, bool option
         GetRpcResult("platformP2PPort", /*optional=*/true),
         GetRpcResult("platformHTTPPort", /*optional=*/true),
         GetRpcResult("payoutAddress", /*optional=*/true),
+        GetRpcResult("payouts", /*optional=*/true),
         GetRpcResult("pubKeyOperator"),
         GetRpcResult("operatorPayoutAddress", /*optional=*/true),
     }};
@@ -243,7 +254,9 @@ UniValue CDeterministicMNState::ToJson(MnType nType) const
     }
 
     CTxDestination dest;
-    if (ExtractDestination(scriptPayout, dest)) {
+    if (nVersion >= ProTxVersion::MultiPayout) {
+        obj.pushKV("payouts", PayoutListToJson(payouts));
+    } else if (ExtractDestination(scriptPayout, dest)) {
         obj.pushKV("payoutAddress", EncodeDestination(dest));
     }
     obj.pushKV("pubKeyOperator", pubKeyOperator.ToString());
@@ -270,6 +283,7 @@ RPCResult CDeterministicMNStateDiff::GetJsonHelp(const std::string& key, bool op
         GetRpcResult("ownerAddress", /*optional=*/true),
         GetRpcResult("votingAddress", /*optional=*/true),
         GetRpcResult("payoutAddress", /*optional=*/true),
+        GetRpcResult("payouts", /*optional=*/true),
         GetRpcResult("operatorPayoutAddress", /*optional=*/true),
         GetRpcResult("pubKeyOperator", /*optional=*/true),
         GetRpcResult("platformNodeID", /*optional=*/true),
@@ -292,6 +306,7 @@ RPCResult CProRegTx::GetJsonHelp(const std::string& key, bool optional)
         GetRpcResult("ownerAddress"),
         GetRpcResult("votingAddress"),
         GetRpcResult("payoutAddress", /*optional=*/true),
+        GetRpcResult("payouts", /*optional=*/true),
         GetRpcResult("pubKeyOperator"),
         GetRpcResult("operatorReward"),
         GetRpcResult("platformNodeID", /*optional=*/true),
@@ -314,7 +329,9 @@ UniValue CProRegTx::ToJson() const
     ret.pushKV("addresses", GetNetInfoWithLegacyFields(*this, nType));
     ret.pushKV("ownerAddress", EncodeDestination(PKHash(keyIDOwner)));
     ret.pushKV("votingAddress", EncodeDestination(PKHash(keyIDVoting)));
-    if (CTxDestination dest; ExtractDestination(scriptPayout, dest)) {
+    if (nVersion >= ProTxVersion::MultiPayout) {
+        ret.pushKV("payouts", PayoutListToJson(payouts));
+    } else if (CTxDestination dest; ExtractDestination(scriptPayout, dest)) {
         ret.pushKV("payoutAddress", EncodeDestination(dest));
     }
     ret.pushKV("pubKeyOperator", pubKeyOperator.ToString());
@@ -338,6 +355,7 @@ RPCResult CProUpRegTx::GetJsonHelp(const std::string& key, bool optional)
         GetRpcResult("proTxHash"),
         GetRpcResult("votingAddress"),
         GetRpcResult("payoutAddress", /*optional=*/true),
+        GetRpcResult("payouts", /*optional=*/true),
         GetRpcResult("pubKeyOperator"),
         GetRpcResult("inputsHash"),
     }};
@@ -349,7 +367,9 @@ UniValue CProUpRegTx::ToJson() const
     ret.pushKV("version", nVersion);
     ret.pushKV("proTxHash", proTxHash.ToString());
     ret.pushKV("votingAddress", EncodeDestination(PKHash(keyIDVoting)));
-    if (CTxDestination dest; ExtractDestination(scriptPayout, dest)) {
+    if (nVersion >= ProTxVersion::MultiPayout) {
+        ret.pushKV("payouts", PayoutListToJson(payouts));
+    } else if (CTxDestination dest; ExtractDestination(scriptPayout, dest)) {
         ret.pushKV("payoutAddress", EncodeDestination(dest));
     }
     ret.pushKV("pubKeyOperator", pubKeyOperator.ToString());
@@ -528,6 +548,7 @@ RPCResult CSimplifiedMNListEntry::GetJsonHelp(const std::string& key, bool optio
         GetRpcResult("platformHTTPPort", /*optional=*/true),
         GetRpcResult("platformNodeID", /*optional=*/true),
         GetRpcResult("payoutAddress", /*optional=*/true),
+        GetRpcResult("payouts", /*optional=*/true),
         GetRpcResult("operatorPayoutAddress", /*optional=*/true),
     }};
 }
@@ -555,7 +576,9 @@ UniValue CSimplifiedMNListEntry::ToJson(bool extended) const
 
     if (extended) {
         CTxDestination dest;
-        if (ExtractDestination(scriptPayout, dest)) {
+        if (nVersion >= ProTxVersion::MultiPayout) {
+            obj.pushKV("payouts", PayoutListToJson(payouts));
+        } else if (ExtractDestination(scriptPayout, dest)) {
             obj.pushKV("payoutAddress", EncodeDestination(dest));
         }
         if (ExtractDestination(scriptOperatorPayout, dest)) {
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index 9c70869382c3..df22b9198362 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -45,7 +45,8 @@ CSimplifiedMNListEntry CDeterministicMN::to_sml_entry() const
     const CDeterministicMNState& state{*pdmnState};
     return CSimplifiedMNListEntry(proTxHash, state.confirmedHash, state.netInfo, state.pubKeyOperator,
                                   state.keyIDVoting, !state.IsBanned(), state.platformHTTPPort, state.platformNodeID,
-                                  state.scriptPayout, state.scriptOperatorPayout, state.nVersion, nType);
+                                  state.scriptPayout, GetOwnerPayouts(state.nVersion, state.scriptPayout, state.payouts),
+                                  state.scriptOperatorPayout, state.nVersion, nType);
 }
 
 std::string CDeterministicMN::ToString() const
diff --git a/src/evo/dmnstate.cpp b/src/evo/dmnstate.cpp
index 8d0601b5a6bf..2818f783e8f4 100644
--- a/src/evo/dmnstate.cpp
+++ b/src/evo/dmnstate.cpp
@@ -16,17 +16,19 @@ std::string CDeterministicMNState::ToString() const
     if (ExtractDestination(scriptPayout, dest)) {
         payoutAddress = EncodeDestination(dest);
     }
+    const auto owner_payouts = GetOwnerPayouts(nVersion, scriptPayout, payouts);
+    const std::string payoutList = PayoutListToString(owner_payouts);
     if (ExtractDestination(scriptOperatorPayout, dest)) {
         operatorPayoutAddress = EncodeDestination(dest);
     }
 
     return strprintf("CDeterministicMNState(nVersion=%d, nRegisteredHeight=%d, nLastPaidHeight=%d, nPoSePenalty=%d, "
                      "nPoSeRevivedHeight=%d, nPoSeBanHeight=%d, nRevocationReason=%d, "
-                     "ownerAddress=%s, pubKeyOperator=%s, votingAddress=%s, netInfo=%s, payoutAddress=%s, "
+                     "ownerAddress=%s, pubKeyOperator=%s, votingAddress=%s, netInfo=%s, payoutAddress=%s, payouts=%s, "
                      "operatorPayoutAddress=%s)\n",
                      nVersion, nRegisteredHeight, nLastPaidHeight, nPoSePenalty, nPoSeRevivedHeight, nPoSeBanHeight,
                      nRevocationReason, EncodeDestination(PKHash(keyIDOwner)), pubKeyOperator.ToString(),
-                     EncodeDestination(PKHash(keyIDVoting)), netInfo->ToString(), payoutAddress, operatorPayoutAddress);
+                     EncodeDestination(PKHash(keyIDVoting)), netInfo->ToString(), payoutAddress, payoutList, operatorPayoutAddress);
 }
 
 UniValue CDeterministicMNStateDiff::ToJson(MnType nType) const
@@ -73,6 +75,9 @@ UniValue CDeterministicMNStateDiff::ToJson(MnType nType) const
             obj.pushKV("payoutAddress", EncodeDestination(dest));
         }
     }
+    if (fields & Field_payouts) {
+        obj.pushKV("payouts", PayoutListToJson(state.payouts));
+    }
     if (fields & Field_scriptOperatorPayout) {
         CTxDestination dest;
         if (ExtractDestination(state.scriptOperatorPayout, dest)) {
diff --git a/src/evo/dmnstate.h b/src/evo/dmnstate.h
index bb1a23f2074c..dfab76d1e25b 100644
--- a/src/evo/dmnstate.h
+++ b/src/evo/dmnstate.h
@@ -57,6 +57,7 @@ class CDeterministicMNState
     CKeyID keyIDVoting;
     std::shared_ptr<NetInfoInterface> netInfo{nullptr};
     CScript scriptPayout;
+    MasternodePayoutShares payouts;
     CScript scriptOperatorPayout;
 
     uint160 platformNodeID{};
@@ -72,6 +73,7 @@ class CDeterministicMNState
         keyIDVoting(proTx.keyIDVoting),
         netInfo(proTx.netInfo),
         scriptPayout(proTx.scriptPayout),
+        payouts(proTx.payouts),
         platformNodeID(proTx.platformNodeID),
         platformP2PPort(proTx.platformP2PPort),
         platformHTTPPort(proTx.platformHTTPPort)
@@ -98,8 +100,13 @@ class CDeterministicMNState
         READWRITE(
             obj.keyIDVoting,
             NetInfoSerWrapper(const_cast<std::shared_ptr<NetInfoInterface>&>(obj.netInfo),
-                              obj.nVersion >= ProTxVersion::ExtAddr),
-            obj.scriptPayout,
+                              obj.nVersion >= ProTxVersion::ExtAddr));
+        if (obj.nVersion >= ProTxVersion::MultiPayout) {
+            READWRITE(obj.payouts);
+        } else {
+            READWRITE(obj.scriptPayout);
+        }
+        READWRITE(
             obj.scriptOperatorPayout,
             obj.platformNodeID);
         if (obj.nVersion < ProTxVersion::ExtAddr) {
@@ -176,6 +183,7 @@ class CDeterministicMNStateDiff
         Field_platformNodeID = 0x10000,
         Field_platformP2PPort = 0x20000,
         Field_platformHTTPPort = 0x40000,
+        Field_payouts = 0x80000,
     };
 
 private:
@@ -203,6 +211,7 @@ class CDeterministicMNStateDiff
         DMN_STATE_MEMBER(keyIDVoting),
         DMN_STATE_MEMBER(netInfo),
         DMN_STATE_MEMBER(scriptPayout),
+        DMN_STATE_MEMBER(payouts),
         DMN_STATE_MEMBER(scriptOperatorPayout),
         DMN_STATE_MEMBER(nConsecutivePayments),
         DMN_STATE_MEMBER(platformNodeID),
diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index b2c3691aa4f5..d098690fd1ba 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -15,16 +15,21 @@
 #include <tinyformat.h>
 #include <validation.h>
 
+#include <set>
+
 namespace ProTxVersion {
 template <typename T>
 [[nodiscard]] uint16_t GetMaxFromDeployment(gsl::not_null<const CBlockIndex*> pindexPrev,
                                             const ChainstateManager& chainman, std::optional<bool> is_basic_override)
 {
     constexpr bool is_extaddr_eligible{std::is_same_v<std::decay_t<T>, CProRegTx> || std::is_same_v<std::decay_t<T>, CProUpServTx>};
+    constexpr bool is_multipayout_eligible{std::is_same_v<std::decay_t<T>, CProRegTx> || std::is_same_v<std::decay_t<T>, CProUpRegTx>};
+    const bool is_v24_active{DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)};
     return ProTxVersion::GetMax(
         is_basic_override ? *is_basic_override
                           : DeploymentActiveAfter(pindexPrev, chainman.GetConsensus(), Consensus::DEPLOYMENT_V19),
-        is_extaddr_eligible ? DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24) : false);
+        is_extaddr_eligible ? is_v24_active : false,
+        is_multipayout_eligible ? is_v24_active : false);
 }
 template uint16_t GetMaxFromDeployment<CProRegTx>(gsl::not_null<const CBlockIndex*> pindexPrev,
                                                   const ChainstateManager& chainman,
@@ -40,6 +45,69 @@ template uint16_t GetMaxFromDeployment<CProUpRevTx>(gsl::not_null<const CBlockIn
                                                     std::optional<bool> is_basic_override);
 } // namespace ProTxVersion
 
+static bool IsValidPayoutScript(const CScript& script)
+{
+    return script.IsPayToPublicKeyHash() || script.IsPayToScriptHash();
+}
+
+bool IsPayoutListTriviallyValid(const MasternodePayoutShares& payouts, const CKeyID& keyIDOwner,
+                                const CKeyID& keyIDVoting, TxValidationState& state)
+{
+    if (payouts.empty() || payouts.size() > 8) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payouts-count");
+    }
+
+    uint32_t total_reward{0};
+    std::set<CScript> seen_scripts;
+    for (const auto& payout : payouts) {
+        if (payout.reward < CMasternodePayoutShare::MIN_REWARD || payout.reward > CMasternodePayoutShare::MAX_REWARD) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payout-reward");
+        }
+        total_reward += payout.reward;
+
+        if (!IsValidPayoutScript(payout.scriptPayout)) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee");
+        }
+        if (!seen_scripts.emplace(payout.scriptPayout).second) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-dup");
+        }
+
+        CTxDestination payout_dest;
+        if (!ExtractDestination(payout.scriptPayout, payout_dest)) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-dest");
+        }
+        if ((!keyIDOwner.IsNull() && payout_dest == CTxDestination(PKHash(keyIDOwner))) ||
+            payout_dest == CTxDestination(PKHash(keyIDVoting))) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-reuse");
+        }
+    }
+
+    if (total_reward != CMasternodePayoutShare::MAX_REWARD) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payout-reward-sum");
+    }
+    return true;
+}
+
+bool IsPayoutListKeySafe(const MasternodePayoutShares& payouts, const CTxDestination& collateral_dest,
+                         const CKeyID& keyIDOwner, const CKeyID& keyIDVoting,
+                         bool check_payout_collateral_reuse, TxValidationState& state)
+{
+    if (collateral_dest == CTxDestination(PKHash(keyIDOwner)) ||
+        collateral_dest == CTxDestination(PKHash(keyIDVoting))) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-reuse");
+    }
+
+    if (check_payout_collateral_reuse) {
+        for (const auto& payout : payouts) {
+            CTxDestination payout_dest;
+            if (ExtractDestination(payout.scriptPayout, payout_dest) && payout_dest == collateral_dest) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-reuse");
+            }
+        }
+    }
+    return true;
+}
+
 template <typename ProTx>
 bool IsNetInfoTriviallyValid(const ProTx& proTx, TxValidationState& state)
 {
@@ -86,10 +154,9 @@ bool CProRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, c
     if (pubKeyOperator.IsLegacy() != (nVersion == ProTxVersion::LegacyBLS)) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-operator-pubkey");
     }
-    if (!scriptPayout.IsPayToPublicKeyHash() && !scriptPayout.IsPayToScriptHash()) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee");
-    }
-    if (netInfo->CanStorePlatform() != (nVersion == ProTxVersion::ExtAddr)) {
+    const auto owner_payouts = GetOwnerPayouts(nVersion, scriptPayout, payouts);
+    if (!IsPayoutListTriviallyValid(owner_payouts, keyIDOwner, keyIDVoting, state)) return false;
+    if (netInfo->CanStorePlatform() != (nVersion >= ProTxVersion::ExtAddr)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-netinfo-version");
     }
     if (!netInfo->IsEmpty() && !IsNetInfoTriviallyValid(*this, state)) {
@@ -102,16 +169,6 @@ bool CProRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, c
         }
     }
 
-    CTxDestination payoutDest;
-    if (!ExtractDestination(scriptPayout, payoutDest)) {
-        // should not happen as we checked script types before
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-dest");
-    }
-    // don't allow reuse of payout key for other keys (don't allow people to put the payee key onto an online server)
-    if (payoutDest == CTxDestination(PKHash(keyIDOwner)) || payoutDest == CTxDestination(PKHash(keyIDVoting))) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-reuse");
-    }
-
     if (nOperatorReward > 10000) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-operator-reward");
     }
@@ -125,13 +182,10 @@ std::string CProRegTx::MakeSignString() const
 
     // We only include the important stuff in the string form...
 
-    CTxDestination destPayout;
-    std::string strPayout;
-    if (ExtractDestination(scriptPayout, destPayout)) {
-        strPayout = EncodeDestination(destPayout);
-    } else {
-        strPayout = HexStr(scriptPayout);
-    }
+    CTxDestination dest;
+    const std::string strPayout = nVersion >= ProTxVersion::MultiPayout
+        ? PayoutListToString(payouts)
+        : (ExtractDestination(scriptPayout, dest) ? EncodeDestination(dest) : HexStr(scriptPayout));
 
     s += strPayout + "|";
     s += strprintf("%d", nOperatorReward) + "|";
@@ -146,11 +200,7 @@ std::string CProRegTx::MakeSignString() const
 
 std::string CProRegTx::ToString() const
 {
-    CTxDestination dest;
-    std::string payee = "unknown";
-    if (ExtractDestination(scriptPayout, dest)) {
-        payee = EncodeDestination(dest);
-    }
+    const std::string payee = PayoutListToString(GetOwnerPayouts(nVersion, scriptPayout, payouts));
 
     return strprintf("CProRegTx(nVersion=%d, nType=%d, collateralOutpoint=%s, netInfo=%s, nOperatorReward=%f, "
                      "ownerAddress=%s, pubKeyOperator=%s, votingAddress=%s, scriptPayout=%s, platformNodeID=%s%s)\n",
@@ -171,7 +221,7 @@ bool CProUpServTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev
     if (nVersion < ProTxVersion::BasicBLS && nType == MnType::Evo) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-evo-version");
     }
-    if (netInfo->CanStorePlatform() != (nVersion == ProTxVersion::ExtAddr)) {
+    if (netInfo->CanStorePlatform() != (nVersion >= ProTxVersion::ExtAddr)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-netinfo-version");
     }
     if (netInfo->IsEmpty()) {
@@ -223,19 +273,13 @@ bool CProUpRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev,
     if (pubKeyOperator.IsLegacy() != (nVersion == ProTxVersion::LegacyBLS)) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-operator-pubkey");
     }
-    if (!scriptPayout.IsPayToPublicKeyHash() && !scriptPayout.IsPayToScriptHash()) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee");
-    }
+    if (!IsPayoutListTriviallyValid(GetOwnerPayouts(nVersion, scriptPayout, payouts), CKeyID{}, keyIDVoting, state)) return false;
     return true;
 }
 
 std::string CProUpRegTx::ToString() const
 {
-    CTxDestination dest;
-    std::string payee = "unknown";
-    if (ExtractDestination(scriptPayout, dest)) {
-        payee = EncodeDestination(dest);
-    }
+    const std::string payee = PayoutListToString(GetOwnerPayouts(nVersion, scriptPayout, payouts));
 
     return strprintf("CProUpRegTx(nVersion=%d, proTxHash=%s, pubKeyOperator=%s, votingAddress=%s, payoutAddress=%s)",
         nVersion, proTxHash.ToString(), pubKeyOperator.ToString(), EncodeDestination(PKHash(keyIDVoting)), payee);
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index 68c6fe3c7aa2..a8c24d34b80b 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -20,6 +20,8 @@
 #include <univalue.h>
 #include <gsl/pointers.h>
 
+#include <vector>
+
 class CBlockIndex;
 class ChainstateManager;
 class TxValidationState;
@@ -30,12 +32,17 @@ enum : uint16_t {
     LegacyBLS = 1,
     BasicBLS  = 2,
     ExtAddr   = 3,
+    MultiPayout = 4,
 };
 
 /** Get highest permissible ProTx version based on flags set. */
-[[nodiscard]] constexpr uint16_t GetMax(const bool is_basic_scheme_active, const bool is_extended_addr)
+[[nodiscard]] constexpr uint16_t GetMax(const bool is_basic_scheme_active, const bool is_extended_addr,
+                                        const bool is_multi_payout = false)
 {
     if (is_basic_scheme_active) {
+        if (is_multi_payout) {
+            return ProTxVersion::MultiPayout;
+        }
         if (is_extended_addr) {
             // Requires *both* forks to be active to use extended addresses. is_basic_scheme_active could
             // be set to false due to RPC specialization, so we must evaluate is_extended_addr *last* to
@@ -57,6 +64,47 @@ template <typename T>
                                             std::optional<bool> is_basic_override = std::nullopt);
 } // namespace ProTxVersion
 
+class CMasternodePayoutShare
+{
+public:
+    static constexpr uint16_t MIN_REWARD = 100;
+    static constexpr uint16_t MAX_REWARD = 10000;
+
+    CScript scriptPayout;
+    uint16_t reward{MAX_REWARD};
+
+    CMasternodePayoutShare() = default;
+    CMasternodePayoutShare(CScript script_payout, uint16_t reward) :
+        scriptPayout(std::move(script_payout)),
+        reward(reward)
+    {
+    }
+
+    SERIALIZE_METHODS(CMasternodePayoutShare, obj)
+    {
+        READWRITE(obj.scriptPayout, obj.reward);
+    }
+
+    friend bool operator==(const CMasternodePayoutShare& a, const CMasternodePayoutShare& b)
+    {
+        return a.reward == b.reward && a.scriptPayout == b.scriptPayout;
+    }
+    friend bool operator!=(const CMasternodePayoutShare& a, const CMasternodePayoutShare& b) { return !(a == b); }
+};
+
+using MasternodePayoutShares = std::vector<CMasternodePayoutShare>;
+
+[[nodiscard]] MasternodePayoutShares LegacyPayoutAsList(const CScript& script_payout);
+[[nodiscard]] MasternodePayoutShares GetOwnerPayouts(uint16_t nVersion, const CScript& script_payout,
+                                                     const MasternodePayoutShares& payouts);
+[[nodiscard]] bool IsPayoutListTriviallyValid(const MasternodePayoutShares& payouts, const CKeyID& keyIDOwner,
+                                              const CKeyID& keyIDVoting, TxValidationState& state);
+[[nodiscard]] bool IsPayoutListKeySafe(const MasternodePayoutShares& payouts, const CTxDestination& collateral_dest,
+                                       const CKeyID& keyIDOwner, const CKeyID& keyIDVoting,
+                                       bool check_payout_collateral_reuse, TxValidationState& state);
+[[nodiscard]] std::string PayoutListToString(const MasternodePayoutShares& payouts);
+[[nodiscard]] UniValue PayoutListToJson(const MasternodePayoutShares& payouts);
+
 class CProRegTx
 {
 public:
@@ -75,6 +123,7 @@ class CProRegTx
     CKeyID keyIDVoting;
     uint16_t nOperatorReward{0};
     CScript scriptPayout;
+    MasternodePayoutShares payouts;
     uint256 inputsHash; // replay protection
     std::vector<unsigned char> vchSig;
 
@@ -84,7 +133,7 @@ class CProRegTx
                 obj.nVersion
         );
         if (obj.nVersion == 0 ||
-            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true, /*is_multi_payout=*/true)) {
             // unknown version, bail out early
             return;
         }
@@ -98,8 +147,20 @@ class CProRegTx
                 obj.keyIDOwner,
                 CBLSLazyPublicKeyVersionWrapper(const_cast<CBLSLazyPublicKey&>(obj.pubKeyOperator), (obj.nVersion == ProTxVersion::LegacyBLS)),
                 obj.keyIDVoting,
-                obj.nOperatorReward,
-                obj.scriptPayout,
+                obj.nOperatorReward
+        );
+        if (obj.nVersion >= ProTxVersion::MultiPayout) {
+            uint8_t payouts_count{0};
+            SER_WRITE(obj, payouts_count = static_cast<uint8_t>(obj.payouts.size()));
+            READWRITE(payouts_count);
+            SER_READ(obj, obj.payouts.resize(payouts_count));
+            for (auto& payout : obj.payouts) {
+                READWRITE(payout);
+            }
+        } else {
+            READWRITE(obj.scriptPayout);
+        }
+        READWRITE(
                 obj.inputsHash
         );
         if (obj.nType == MnType::Evo) {
@@ -151,7 +212,7 @@ class CProUpServTx
                 obj.nVersion
         );
         if (obj.nVersion == 0 ||
-            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true, /*is_multi_payout=*/true)) {
             // unknown version, bail out early
             return;
         }
@@ -202,6 +263,7 @@ class CProUpRegTx
     CBLSLazyPublicKey pubKeyOperator;
     CKeyID keyIDVoting;
     CScript scriptPayout;
+    MasternodePayoutShares payouts;
     uint256 inputsHash; // replay protection
     std::vector<unsigned char> vchSig;
 
@@ -211,7 +273,7 @@ class CProUpRegTx
                 obj.nVersion
         );
         if (obj.nVersion == 0 ||
-            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true, /*is_multi_payout=*/true)) {
             // unknown version, bail out early
             return;
         }
@@ -219,8 +281,20 @@ class CProUpRegTx
                 obj.proTxHash,
                 obj.nMode,
                 CBLSLazyPublicKeyVersionWrapper(const_cast<CBLSLazyPublicKey&>(obj.pubKeyOperator), (obj.nVersion == ProTxVersion::LegacyBLS)),
-                obj.keyIDVoting,
-                obj.scriptPayout,
+                obj.keyIDVoting
+        );
+        if (obj.nVersion >= ProTxVersion::MultiPayout) {
+            uint8_t payouts_count{0};
+            SER_WRITE(obj, payouts_count = static_cast<uint8_t>(obj.payouts.size()));
+            READWRITE(payouts_count);
+            SER_READ(obj, obj.payouts.resize(payouts_count));
+            for (auto& payout : obj.payouts) {
+                READWRITE(payout);
+            }
+        } else {
+            READWRITE(obj.scriptPayout);
+        }
+        READWRITE(
                 obj.inputsHash
         );
         if (!(s.GetType() & SER_GETHASH)) {
@@ -265,7 +339,7 @@ class CProUpRevTx
                 obj.nVersion
         );
         if (obj.nVersion == 0 ||
-            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true, /*is_multi_payout=*/true)) {
             // unknown version, bail out early
             return;
         }
diff --git a/src/evo/providertx_util.cpp b/src/evo/providertx_util.cpp
new file mode 100644
index 000000000000..0d963b4fb6d6
--- /dev/null
+++ b/src/evo/providertx_util.cpp
@@ -0,0 +1,56 @@
+// Copyright (c) 2018-2025 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <evo/providertx.h>
+
+#include <key_io.h>
+#include <script/standard.h>
+#include <tinyformat.h>
+#include <univalue.h>
+#include <util/strencodings.h>
+
+// Owner payout list helpers that operate purely on the serialized representation. They live in
+// libbitcoin_common (rather than libbitcoin_node alongside the rest of providertx.cpp) so that
+// common-layer consumers like the bloom filter and the JSON writers can use them without pulling
+// in node-only dependencies.
+
+MasternodePayoutShares LegacyPayoutAsList(const CScript& script_payout)
+{
+    return {{script_payout, CMasternodePayoutShare::MAX_REWARD}};
+}
+
+MasternodePayoutShares GetOwnerPayouts(const uint16_t nVersion, const CScript& script_payout,
+                                       const MasternodePayoutShares& payouts)
+{
+    return nVersion >= ProTxVersion::MultiPayout ? payouts : LegacyPayoutAsList(script_payout);
+}
+
+std::string PayoutListToString(const MasternodePayoutShares& payouts)
+{
+    std::string ret;
+    for (const auto& payout : payouts) {
+        CTxDestination dest;
+        const std::string payout_str = ExtractDestination(payout.scriptPayout, dest) ? EncodeDestination(dest) : HexStr(payout.scriptPayout);
+        if (!ret.empty()) ret += ",";
+        ret += strprintf("%s:%d", payout_str, payout.reward);
+    }
+    return ret;
+}
+
+UniValue PayoutListToJson(const MasternodePayoutShares& payouts)
+{
+    UniValue ret(UniValue::VARR);
+    for (const auto& payout : payouts) {
+        UniValue obj(UniValue::VOBJ);
+        // Payout scripts are required to be P2PKH or P2SH (see IsPayoutListTriviallyValid), so a
+        // destination can always be extracted and the address is always present.
+        CTxDestination dest;
+        ExtractDestination(payout.scriptPayout, dest);
+        obj.pushKV("address", EncodeDestination(dest));
+        obj.pushKV("script", HexStr(payout.scriptPayout));
+        obj.pushKV("reward", payout.reward);
+        ret.push_back(obj);
+    }
+    return ret;
+}
diff --git a/src/evo/simplifiedmns.cpp b/src/evo/simplifiedmns.cpp
index 911c1da8756c..da7d9f1ad97e 100644
--- a/src/evo/simplifiedmns.cpp
+++ b/src/evo/simplifiedmns.cpp
@@ -23,6 +23,7 @@ CSimplifiedMNListEntry::CSimplifiedMNListEntry(const uint256& proreg_tx_hash, co
                                                const CBLSLazyPublicKey& pubkey_operator, const CKeyID& keyid_voting,
                                                bool is_valid, uint16_t platform_http_port,
                                                const uint160& platform_node_id, const CScript& script_payout,
+                                               const MasternodePayoutShares& payouts_in,
                                                const CScript& script_operator_payout, uint16_t version, MnType type) :
     proRegTxHash(proreg_tx_hash),
     confirmedHash(confirmed_hash),
@@ -33,6 +34,7 @@ CSimplifiedMNListEntry::CSimplifiedMNListEntry(const uint256& proreg_tx_hash, co
     platformHTTPPort(platform_http_port),
     platformNodeID(platform_node_id),
     scriptPayout(script_payout),
+    payouts(payouts_in),
     scriptOperatorPayout(script_operator_payout),
     nVersion(version),
     nType(type)
diff --git a/src/evo/simplifiedmns.h b/src/evo/simplifiedmns.h
index fca52d88fa03..52d1088e8893 100644
--- a/src/evo/simplifiedmns.h
+++ b/src/evo/simplifiedmns.h
@@ -36,6 +36,7 @@ class CSimplifiedMNListEntry
     uint16_t platformHTTPPort{0};
     uint160 platformNodeID{};
     CScript scriptPayout; // mem-only
+    MasternodePayoutShares payouts; // mem-only
     CScript scriptOperatorPayout; // mem-only
     uint16_t nVersion{ProTxVersion::LegacyBLS};
     MnType nType{MnType::Regular};
@@ -45,7 +46,8 @@ class CSimplifiedMNListEntry
                            const std::shared_ptr<NetInfoInterface>& net_info, const CBLSLazyPublicKey& pubkey_operator,
                            const CKeyID& keyid_voting, bool is_valid, uint16_t platform_http_port,
                            const uint160& platform_node_id, const CScript& script_payout,
-                           const CScript& script_operator_payout, uint16_t version, MnType type);
+                           const MasternodePayoutShares& payouts, const CScript& script_operator_payout,
+                           uint16_t version, MnType type);
 
     bool operator==(const CSimplifiedMNListEntry& rhs) const
     {
diff --git a/src/evo/smldiff.cpp b/src/evo/smldiff.cpp
index 0e0366a1e3ce..3c0991ea33c4 100644
--- a/src/evo/smldiff.cpp
+++ b/src/evo/smldiff.cpp
@@ -134,6 +134,7 @@ CSimplifiedMNListDiff BuildSimplifiedDiff(const CDeterministicMNList& from, cons
             CSimplifiedMNListEntry sme1{toPtr.to_sml_entry()};
             CSimplifiedMNListEntry sme2(fromPtr->to_sml_entry());
             if ((sme1 != sme2) || (extended && (sme1.scriptPayout != sme2.scriptPayout ||
+                                                sme1.payouts != sme2.payouts ||
                                                 sme1.scriptOperatorPayout != sme2.scriptOperatorPayout))) {
                 diffRet.mnList.push_back(std::move(sme1));
             }
diff --git a/src/evo/specialtx_filter.cpp b/src/evo/specialtx_filter.cpp
index b61173dc7587..cd11be7708f6 100644
--- a/src/evo/specialtx_filter.cpp
+++ b/src/evo/specialtx_filter.cpp
@@ -72,8 +72,10 @@ void ExtractSpecialTxFilterElements(const CTransaction& tx, const std::function<
             // Add voting key ID
             AddHashElement(opt_proTx->keyIDVoting, addElement);
 
-            // Add payout script
-            AddScriptElement(opt_proTx->scriptPayout, addElement);
+            // Add owner payout scripts
+            for (const auto& payout : GetOwnerPayouts(opt_proTx->nVersion, opt_proTx->scriptPayout, opt_proTx->payouts)) {
+                AddScriptElement(payout.scriptPayout, addElement);
+            }
         }
         break;
     }
@@ -95,8 +97,10 @@ void ExtractSpecialTxFilterElements(const CTransaction& tx, const std::function<
             // Add voting key ID
             AddHashElement(opt_proTx->keyIDVoting, addElement);
 
-            // Add payout script
-            AddScriptElement(opt_proTx->scriptPayout, addElement);
+            // Add owner payout scripts
+            for (const auto& payout : GetOwnerPayouts(opt_proTx->nVersion, opt_proTx->scriptPayout, opt_proTx->payouts)) {
+                AddScriptElement(payout.scriptPayout, addElement);
+            }
         }
         break;
     }
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 65b1e6c4e2c6..16021e27c83e 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -30,6 +30,69 @@
 #include <util/system.h>
 #include <validation.h>
 
+static bool AddNetInfoEntries(const std::shared_ptr<NetInfoInterface>& net_info, NetInfoPurpose purpose,
+                              const NetInfoList& entries, BlockValidationState& state)
+{
+    for (const auto& entry : entries) {
+        if (const auto ret{net_info->AddEntry(purpose, entry.ToStringAddrPort())}; ret != NetInfoStatus::Success) {
+            return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-netinfo-version");
+        }
+    }
+    return true;
+}
+
+static bool SetStateVersion(CDeterministicMNState& state_mn, uint16_t nVersion, MnType nType,
+                            BlockValidationState& state)
+{
+    const bool needs_extended = nVersion >= ProTxVersion::ExtAddr;
+    if (state_mn.nVersion == nVersion && state_mn.netInfo->CanStorePlatform() == needs_extended) {
+        return true;
+    }
+
+    auto converted_netinfo{NetInfoInterface::MakeNetInfo(nVersion)};
+    if (needs_extended) {
+        if (!AddNetInfoEntries(converted_netinfo, NetInfoPurpose::CORE_P2P,
+                               state_mn.netInfo->GetEntries(NetInfoPurpose::CORE_P2P), state)) {
+            return false;
+        }
+        if (state_mn.netInfo->CanStorePlatform()) {
+            if (!AddNetInfoEntries(converted_netinfo, NetInfoPurpose::PLATFORM_P2P,
+                                   state_mn.netInfo->GetEntries(NetInfoPurpose::PLATFORM_P2P), state) ||
+                !AddNetInfoEntries(converted_netinfo, NetInfoPurpose::PLATFORM_HTTPS,
+                                   state_mn.netInfo->GetEntries(NetInfoPurpose::PLATFORM_HTTPS), state)) {
+                return false;
+            }
+        } else if (nType == MnType::Evo && !state_mn.netInfo->IsEmpty()) {
+            const CNetAddr addr{state_mn.netInfo->GetPrimary()};
+            if ((state_mn.platformP2PPort != 0 &&
+                 converted_netinfo->AddEntry(NetInfoPurpose::PLATFORM_P2P,
+                                             CService(addr, state_mn.platformP2PPort).ToStringAddrPort()) != NetInfoStatus::Success) ||
+                (state_mn.platformHTTPPort != 0 &&
+                 converted_netinfo->AddEntry(NetInfoPurpose::PLATFORM_HTTPS,
+                                             CService(addr, state_mn.platformHTTPPort).ToStringAddrPort()) != NetInfoStatus::Success)) {
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-netinfo-version");
+            }
+        }
+        state_mn.platformP2PPort = 0;
+        state_mn.platformHTTPPort = 0;
+    } else {
+        if (!AddNetInfoEntries(converted_netinfo, NetInfoPurpose::CORE_P2P,
+                               state_mn.netInfo->GetEntries(NetInfoPurpose::CORE_P2P), state)) {
+            return false;
+        }
+        if (nType == MnType::Evo && state_mn.netInfo->CanStorePlatform() && !state_mn.netInfo->IsEmpty()) {
+            const auto p2p_entries{state_mn.netInfo->GetEntries(NetInfoPurpose::PLATFORM_P2P)};
+            const auto http_entries{state_mn.netInfo->GetEntries(NetInfoPurpose::PLATFORM_HTTPS)};
+            state_mn.platformP2PPort = p2p_entries.empty() ? 0 : p2p_entries.front().GetPort();
+            state_mn.platformHTTPPort = http_entries.empty() ? 0 : http_entries.front().GetPort();
+        }
+    }
+
+    state_mn.nVersion = nVersion;
+    state_mn.netInfo = std::move(converted_netinfo);
+    return true;
+}
+
 static bool CheckCbTxBestChainlock(const CCbTx& cbTx, const CBlockIndex* pindex, const Consensus::Params& consensus_params,
                                    const CChain& chain, const llmq::CQuorumManager& qman,
                                    const chainlock::Chainlocks& chainlocks, BlockValidationState& state)
@@ -345,6 +408,8 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
             }
 
             auto newState = std::make_shared<CDeterministicMNState>(*dmn->pdmnState);
+            const uint16_t current_version{static_cast<uint16_t>(newState->nVersion)};
+            const uint16_t target_version{is_v24_deployed ? std::max<uint16_t>(current_version, opt_proTx->nVersion) : current_version};
             if (is_v24_deployed) {
                 // Extended addresses support in v24 means that the version can be updated
                 newState->nVersion = opt_proTx->nVersion;
@@ -358,6 +423,9 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
                     newState->platformHTTPPort = opt_proTx->platformHTTPPort;
                 }
             }
+            if (is_v24_deployed && !SetStateVersion(*newState, target_version, dmn->nType, state)) {
+                return false;
+            }
             if (newState->IsBanned()) {
                 // only revive when all keys are set
                 if (newState->pubKeyOperator != CBLSLazyPublicKey() && !newState->keyIDVoting.IsNull() &&
@@ -385,18 +453,32 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-hash");
             }
             auto newState = std::make_shared<CDeterministicMNState>(*dmn->pdmnState);
-            if (newState->pubKeyOperator != opt_proTx->pubKeyOperator) {
+            const uint16_t old_version{static_cast<uint16_t>(newState->nVersion)};
+            const bool operator_changed{newState->pubKeyOperator != opt_proTx->pubKeyOperator};
+            const uint16_t target_version{is_v24_deployed ? std::max<uint16_t>(old_version, opt_proTx->nVersion)
+                                                          : (operator_changed ? opt_proTx->nVersion : old_version)};
+            if (operator_changed) {
                 // reset all operator related fields and put MN into PoSe-banned state in case the operator key changes
                 newState->ResetOperatorFields();
                 newState->BanIfNotBanned(nHeight);
-                // we update pubKeyOperator here, make sure state version matches
-                // Make sure we don't accidentally downgrade the state version if using version after basic BLS
-                newState->nVersion = newState->nVersion > ProTxVersion::BasicBLS ? newState->nVersion : opt_proTx->nVersion;
-                newState->netInfo = NetInfoInterface::MakeNetInfo(newState->nVersion);
                 newState->pubKeyOperator = opt_proTx->pubKeyOperator;
             }
             newState->keyIDVoting = opt_proTx->keyIDVoting;
-            newState->scriptPayout = opt_proTx->scriptPayout;
+            if (!SetStateVersion(*newState, target_version, dmn->nType, state)) {
+                return false;
+            }
+            if (operator_changed) {
+                newState->pubKeyOperator.SetLegacy(target_version == ProTxVersion::LegacyBLS);
+            }
+            if (target_version >= ProTxVersion::MultiPayout) {
+                newState->payouts = opt_proTx->nVersion >= ProTxVersion::MultiPayout
+                    ? opt_proTx->payouts
+                    : LegacyPayoutAsList(opt_proTx->scriptPayout);
+                newState->scriptPayout.clear();
+            } else {
+                newState->scriptPayout = opt_proTx->scriptPayout;
+                newState->payouts.clear();
+            }
 
             newList.UpdateMN(opt_proTx->proTxHash, newState);
 
@@ -415,7 +497,11 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-hash");
             }
             auto newState = std::make_shared<CDeterministicMNState>(*dmn->pdmnState);
+            const uint16_t old_version{static_cast<uint16_t>(newState->nVersion)};
             newState->ResetOperatorFields();
+            if (old_version >= ProTxVersion::MultiPayout && !SetStateVersion(*newState, old_version, dmn->nType, state)) {
+                return false;
+            }
             newState->BanIfNotBanned(nHeight);
             newState->nRevocationReason = opt_proTx->nReason;
 
@@ -911,6 +997,9 @@ static bool IsVersionChangeValid(gsl::not_null<const CBlockIndex*> pindexPrev, c
         // Only new entries (ProRegTx) and service updates (ProUpServTx) can use ExtAddr versioning
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-tx-type");
     }
+    if (tx_type != TRANSACTION_PROVIDER_UPDATE_REGISTRAR && tx_version == ProTxVersion::MultiPayout) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-tx-type");
+    }
 
     return true;
 }
@@ -986,10 +1075,9 @@ bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pin
 
     // don't allow reuse of collateral key for other keys (don't allow people to put the collateral key onto an online server)
     // this check applies to internal and external collateral, but internal collaterals are not necessarily a P2PKH
-    if (collateralTxDest == CTxDestination(PKHash(opt_ptx->keyIDOwner)) ||
-        collateralTxDest == CTxDestination(PKHash(opt_ptx->keyIDVoting))) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-reuse");
-    }
+    if (!IsPayoutListKeySafe(GetOwnerPayouts(opt_ptx->nVersion, opt_ptx->scriptPayout, opt_ptx->payouts),
+                             collateralTxDest, opt_ptx->keyIDOwner, opt_ptx->keyIDVoting,
+                             opt_ptx->nVersion >= ProTxVersion::MultiPayout, state)) return false;
 
     if (pindexPrev) {
         auto mnList = dmnman.GetListForBlock(pindexPrev);
@@ -1140,12 +1228,6 @@ bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
         return false;
     }
 
-    CTxDestination payoutDest;
-    if (!ExtractDestination(opt_ptx->scriptPayout, payoutDest)) {
-        // should not happen as we checked script types before
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-dest");
-    }
-
     auto mnList = dmnman.GetListForBlock(pindexPrev);
     auto dmn = mnList.GetMN(opt_ptx->proTxHash);
     if (!dmn) {
@@ -1157,11 +1239,8 @@ bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
         return false;
     }
 
-    // don't allow reuse of payee key for other keys (don't allow people to put the payee key onto an online server)
-    if (payoutDest == CTxDestination(PKHash(dmn->pdmnState->keyIDOwner)) ||
-        payoutDest == CTxDestination(PKHash(opt_ptx->keyIDVoting))) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-reuse");
-    }
+    const auto owner_payouts = GetOwnerPayouts(opt_ptx->nVersion, opt_ptx->scriptPayout, opt_ptx->payouts);
+    if (!IsPayoutListTriviallyValid(owner_payouts, dmn->pdmnState->keyIDOwner, opt_ptx->keyIDVoting, state)) return false;
 
     Coin coin;
     if (!view.GetCoin(dmn->collateralOutpoint, coin) || coin.IsSpent()) {
@@ -1174,10 +1253,10 @@ bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
     if (!ExtractDestination(coin.out.scriptPubKey, collateralTxDest)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-collateral-dest");
     }
-    if (collateralTxDest == CTxDestination(PKHash(dmn->pdmnState->keyIDOwner)) ||
-        collateralTxDest == CTxDestination(PKHash(opt_ptx->keyIDVoting))) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-reuse");
-    }
+    const bool check_payout_collateral_reuse{
+        std::max<uint16_t>(dmn->pdmnState->nVersion, opt_ptx->nVersion) >= ProTxVersion::MultiPayout};
+    if (!IsPayoutListKeySafe(owner_payouts, collateralTxDest, dmn->pdmnState->keyIDOwner, opt_ptx->keyIDVoting,
+                             check_payout_collateral_reuse, state)) return false;
 
     if (mnList.HasUniqueProperty(opt_ptx->pubKeyOperator)) {
         auto otherDmn = mnList.GetUniquePropertyMN(opt_ptx->pubKeyOperator);
diff --git a/src/interfaces/node.h b/src/interfaces/node.h
index 52e241a24ee3..21bab8a95ec3 100644
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -80,6 +80,7 @@ class MnEntry
     virtual const CKeyID& getKeyIdVoting() const = 0;
     virtual const COutPoint& getCollateralOutpoint() const = 0;
     virtual const CScript& getScriptPayout() const = 0;
+    virtual std::vector<CScript> getScriptPayouts() const = 0;
     virtual const CScript& getScriptOperatorPayout() const = 0;
     virtual const int32_t& getLastPaidHeight() const = 0;
     virtual const int32_t& getPoSePenalty() const = 0;
diff --git a/src/masternode/payments.cpp b/src/masternode/payments.cpp
index be5635d15a27..8330c06ac34e 100644
--- a/src/masternode/payments.cpp
+++ b/src/masternode/payments.cpp
@@ -71,8 +71,17 @@ CAmount PlatformShare(const CAmount reward)
         masternodeReward -= operatorReward;
     }
 
-    if (masternodeReward > 0) {
-        voutMasternodePaymentsRet.emplace_back(masternodeReward, dmnPayee->pdmnState->scriptPayout);
+    const auto owner_payouts = GetOwnerPayouts(dmnPayee->pdmnState->nVersion, dmnPayee->pdmnState->scriptPayout,
+                                               dmnPayee->pdmnState->payouts);
+    CAmount paid_owner_reward{0};
+    for (size_t i = 0; i < owner_payouts.size(); ++i) {
+        const bool last = i + 1 == owner_payouts.size();
+        const CAmount payout_amount = last ? masternodeReward - paid_owner_reward
+                                           : (masternodeReward * owner_payouts[i].reward) / CMasternodePayoutShare::MAX_REWARD;
+        paid_owner_reward += payout_amount;
+        if (payout_amount > 0) {
+            voutMasternodePaymentsRet.emplace_back(payout_amount, owner_payouts[i].scriptPayout);
+        }
     }
     if (operatorReward > 0) {
         voutMasternodePaymentsRet.emplace_back(operatorReward, dmnPayee->pdmnState->scriptOperatorPayout);
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index d9fe93f70e41..385ee4aefa78 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -101,15 +101,29 @@ using interfaces::WalletLoader;
 
 namespace node {
 namespace {
+std::vector<CScript> GetOwnerPayoutScripts(const CDeterministicMN& dmn)
+{
+    std::vector<CScript> ret;
+    for (const auto& payout : GetOwnerPayouts(dmn.pdmnState->nVersion, dmn.pdmnState->scriptPayout,
+                                              dmn.pdmnState->payouts)) {
+        ret.emplace_back(payout.scriptPayout);
+    }
+    return ret;
+}
+
 class MnEntryImpl : public MnEntry
 {
 private:
     CDeterministicMNCPtr m_dmn;
+    const std::vector<CScript> m_script_payouts;
+    const CScript m_script_payout;
 
 public:
     MnEntryImpl(const CDeterministicMNCPtr& dmn) :
         MnEntry{dmn},
-        m_dmn{Assert(dmn)}
+        m_dmn{Assert(dmn)},
+        m_script_payouts{GetOwnerPayoutScripts(*m_dmn)},
+        m_script_payout{m_script_payouts.front()}
     {
     }
     ~MnEntryImpl() = default;
@@ -122,7 +136,8 @@ class MnEntryImpl : public MnEntry
     const CKeyID& getKeyIdOwner() const override { return m_dmn->pdmnState->keyIDOwner; }
     const CKeyID& getKeyIdVoting() const override { return m_dmn->pdmnState->keyIDVoting; }
     const COutPoint& getCollateralOutpoint() const override { return m_dmn->collateralOutpoint; }
-    const CScript& getScriptPayout() const override { return m_dmn->pdmnState->scriptPayout; }
+    const CScript& getScriptPayout() const override { return m_script_payout; }
+    std::vector<CScript> getScriptPayouts() const override { return m_script_payouts; }
     const CScript& getScriptOperatorPayout() const override { return m_dmn->pdmnState->scriptOperatorPayout; }
     const int32_t& getLastPaidHeight() const override { return m_dmn->pdmnState->nLastPaidHeight; }
     const int32_t& getPoSePenalty() const override { return m_dmn->pdmnState->nPoSePenalty; }
diff --git a/src/qt/masternodelist.cpp b/src/qt/masternodelist.cpp
index 2ba9e46a78dc..fd5d1fa9dbf9 100644
--- a/src/qt/masternodelist.cpp
+++ b/src/qt/masternodelist.cpp
@@ -220,10 +220,14 @@ void MasternodeList::updateMasternodeList()
 
     QSet<QString> owned_mns;
     for (const auto& entry : feed->m_entries) {
+        const auto script_payouts{entry->scriptPayoutsRaw()};
+        const bool owns_payout{std::any_of(script_payouts.begin(), script_payouts.end(), [&](const auto& script) {
+            return walletModel->wallet().isSpendable(script);
+        })};
         bool fMyMasternode{setOutpts.count(entry->collateralOutpointRaw()) ||
                            walletModel->wallet().isSpendable(PKHash(entry->keyIdOwnerRaw())) ||
                            walletModel->wallet().isSpendable(PKHash(entry->keyIdVotingRaw())) ||
-                           walletModel->wallet().isSpendable(entry->scriptPayoutRaw()) ||
+                           owns_payout ||
                            walletModel->wallet().isSpendable(entry->scriptOperatorPayoutRaw())};
         if (fMyMasternode) {
             owned_mns.insert(entry->proTxHash());
diff --git a/src/qt/masternodemodel.cpp b/src/qt/masternodemodel.cpp
index 2a5353882dc0..a99e754a0dc8 100644
--- a/src/qt/masternodemodel.cpp
+++ b/src/qt/masternodemodel.cpp
@@ -56,11 +56,13 @@ MasternodeEntry::MasternodeEntry(const interfaces::MnEntryCPtr& dmn, const QStri
     auto addr_key = dmn->getNetInfoPrimary().GetKey();
     m_service_key = QByteArray(reinterpret_cast<const char*>(addr_key.data()), addr_key.size());
 
-    if (CTxDestination dest; ExtractDestination(dmn->getScriptPayout(), dest)) {
-        m_payout_address = QString::fromStdString(EncodeDestination(dest));
-    } else {
-        m_payout_address = QObject::tr("UNKNOWN");
+    QStringList payout_addresses;
+    for (const auto& script_payout : dmn->getScriptPayouts()) {
+        if (CTxDestination dest; ExtractDestination(script_payout, dest)) {
+            payout_addresses << QString::fromStdString(EncodeDestination(dest));
+        }
     }
+    m_payout_address = payout_addresses.isEmpty() ? QObject::tr("UNKNOWN") : payout_addresses.join(", ");
 
     if (m_operator_reward_pct) {
         m_operator_reward = QString::number(m_operator_reward_pct / 100.0, 'f', 2) + "%";
diff --git a/src/qt/masternodemodel.h b/src/qt/masternodemodel.h
index ae149264908e..9db5bcf2741d 100644
--- a/src/qt/masternodemodel.h
+++ b/src/qt/masternodemodel.h
@@ -70,6 +70,7 @@ class MasternodeEntry
     const COutPoint& collateralOutpointRaw() const { return m_dmn->getCollateralOutpoint(); }
     const CScript& scriptOperatorPayoutRaw() const { return m_dmn->getScriptOperatorPayout(); }
     const CScript& scriptPayoutRaw() const { return m_dmn->getScriptPayout(); }
+    std::vector<CScript> scriptPayoutsRaw() const { return m_dmn->getScriptPayouts(); }
     const QByteArray& serviceKey() const { return m_service_key; }
     const QString& collateralAddress() const { return m_collateral_address; }
     const QString& collateralOutpoint() const { return m_collateral_outpoint; }
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 655860d6b700..4440f5cba1ff 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -279,34 +279,45 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "protx list", 3, "height" },
     { "protx register", 2, "collateralIndex" },
     { "protx register", 3, "coreP2PAddrs", true },
+    { "protx register", 8, "payoutAddress", true },
     { "protx register", 10, "submit" },
     { "protx register_legacy", 2, "collateralIndex" },
     { "protx register_legacy", 3, "coreP2PAddrs", true },
+    { "protx register_legacy", 8, "payoutAddress", true },
     { "protx register_legacy", 10, "submit" },
     { "protx register_evo", 2, "collateralIndex" },
     { "protx register_evo", 3, "coreP2PAddrs", true },
+    { "protx register_evo", 8, "payoutAddress", true },
     { "protx register_evo", 10, "platformP2PAddrs", true },
     { "protx register_evo", 11, "platformHTTPSAddrs", true },
     { "protx register_evo", 13, "submit" },
     { "protx register_fund", 2, "coreP2PAddrs", true },
+    { "protx register_fund", 7, "payoutAddress", true },
     { "protx register_fund", 9, "submit" },
     { "protx register_fund_legacy", 2, "coreP2PAddrs", true },
+    { "protx register_fund_legacy", 7, "payoutAddress", true },
     { "protx register_fund_legacy", 9, "submit" },
     { "protx register_fund_evo", 2, "coreP2PAddrs", true },
+    { "protx register_fund_evo", 7, "payoutAddress", true },
     { "protx register_fund_evo", 9, "platformP2PAddrs", true },
     { "protx register_fund_evo", 10, "platformHTTPSAddrs", true },
     { "protx register_fund_evo", 12, "submit" },
     { "protx register_prepare", 2, "collateralIndex" },
     { "protx register_prepare", 3, "coreP2PAddrs", true },
+    { "protx register_prepare", 8, "payoutAddress", true },
     { "protx register_prepare_legacy", 2, "collateralIndex" },
     { "protx register_prepare_legacy", 3, "coreP2PAddrs", true },
+    { "protx register_prepare_legacy", 8, "payoutAddress", true },
     { "protx register_prepare_evo", 2, "collateralIndex" },
     { "protx register_prepare_evo", 3, "coreP2PAddrs", true },
+    { "protx register_prepare_evo", 8, "payoutAddress", true },
     { "protx register_prepare_evo", 10, "platformP2PAddrs", true },
     { "protx register_prepare_evo", 11, "platformHTTPSAddrs", true },
     { "protx revoke", 3, "reason" },
     { "protx revoke", 5, "submit" },
+    { "protx update_registrar", 4, "payoutAddress", true },
     { "protx update_registrar", 6, "submit" },
+    { "protx update_registrar_legacy", 4, "payoutAddress", true },
     { "protx update_registrar_legacy", 6, "submit" },
     { "protx update_service", 2, "coreP2PAddrs", true },
     { "protx update_service", 6, "submit" },
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 735f524e808b..2bffdbf04fa6 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -28,6 +28,8 @@
 #include <wallet/rpc/util.h>
 #include <walletinitinterface.h>
 
+#include <limits>
+
 #ifdef ENABLE_WALLET
 #include <wallet/coincontrol.h>
 #include <wallet/spend.h>
@@ -145,13 +147,31 @@ static RPCArg GetRpcArg(const std::string& strParamName)
                 "The address must be unused and must differ from the collateralAddress."}
         },
         {"payoutAddress_register",
-            {"payoutAddress", RPCArg::Type::STR, RPCArg::Optional::NO,
-                "The Dash address to use for masternode reward payments."}
+            {"payoutAddress", RPCArg::Type::ARR, RPCArg::Optional::NO,
+                "The Dash address to use for masternode reward payments, or for v4 provider transactions, "
+                "an array of payout shares.",
+                {
+                    {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
+                        {
+                            {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The Dash payout address."},
+                            {"reward", RPCArg::Type::NUM, RPCArg::Optional::NO, "The payout share in basis points."},
+                        }},
+                },
+                "\"payoutAddress\"|[{\"address\",\"reward\"},...]", {"string or array", "string or array"}}
         },
         {"payoutAddress_update",
-            {"payoutAddress", RPCArg::Type::STR, RPCArg::Optional::NO,
-                "The Dash address to use for masternode reward payments.\n"
-                "If set to an empty string, the currently active payout address is reused."}
+            {"payoutAddress", RPCArg::Type::ARR, RPCArg::Optional::NO,
+                "The Dash address to use for masternode reward payments, or for v4 provider transactions, "
+                "an array of payout shares.\n"
+                "If set to an empty string, the currently active payout address is reused.",
+                {
+                    {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
+                        {
+                            {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The Dash payout address."},
+                            {"reward", RPCArg::Type::NUM, RPCArg::Optional::NO, "The payout share in basis points."},
+                        }},
+                },
+                "\"payoutAddress\"|[{\"address\",\"reward\"},...]", {"string or array", "string or array"}}
         },
         {"proTxHash",
             {"proTxHash", RPCArg::Type::STR, RPCArg::Optional::NO,
@@ -254,6 +274,47 @@ static CBLSPublicKey ParseBLSPubKey(const std::string& hexKey, const std::string
     return pubKey;
 }
 
+static MasternodePayoutShares ParsePayouts(const UniValue& value, const std::string& paramName, CTxDestination& first_dest)
+{
+    MasternodePayoutShares payouts;
+    if (value.isArray()) {
+        const auto& arr = value.get_array();
+        if (arr.empty()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("%s must contain at least one entry", paramName));
+        }
+        for (size_t i = 0; i < arr.size(); ++i) {
+            const UniValue& entry = arr[i];
+            if (!entry.isObject()) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("%s entries must be objects", paramName));
+            }
+            const UniValue& address_value = entry.find_value("address");
+            const UniValue& reward_value = entry.find_value("reward");
+            if (!address_value.isStr() || !reward_value.isNum()) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("%s entries must include address and numeric reward", paramName));
+            }
+            CTxDestination dest = DecodeDestination(address_value.get_str());
+            if (!IsValidDestination(dest)) {
+                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid payout address: %s", address_value.get_str()));
+            }
+            if (payouts.empty()) {
+                first_dest = dest;
+            }
+            const int64_t reward = reward_value.getInt<int64_t>();
+            if (reward < 0 || reward > std::numeric_limits<uint16_t>::max()) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "payout reward out of range");
+            }
+            payouts.emplace_back(GetScriptForDestination(dest), static_cast<uint16_t>(reward));
+        }
+    } else {
+        first_dest = DecodeDestination(value.get_str());
+        if (!IsValidDestination(first_dest)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid payout address: %s", value.get_str()));
+        }
+        payouts.emplace_back(GetScriptForDestination(first_dest), CMasternodePayoutShare::MAX_REWARD);
+    }
+    return payouts;
+}
+
 template <typename SpecialTxPayload>
 static void FundSpecialTx(CWallet& wallet, CMutableTransaction& tx, const SpecialTxPayload& payload,
                           const CTxDestination& fundDest) EXCLUSIVE_LOCKS_REQUIRED(!wallet.cs_wallet)
@@ -743,10 +804,11 @@ static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
     }
     ptx.nOperatorReward = operatorReward;
 
-    CTxDestination payoutDest = DecodeDestination(request.params[paramIdx + 5].get_str());
-    if (!IsValidDestination(payoutDest)) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid payout address: %s", request.params[paramIdx + 5].get_str()));
+    CTxDestination payoutDest;
+    if (request.params[paramIdx + 5].isArray() && ptx.nVersion < ProTxVersion::MultiPayout) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "payouts array requires provider transaction version 4");
     }
+    ptx.payouts = ParsePayouts(request.params[paramIdx + 5], "payouts", payoutDest);
 
     if (isEvoRequested) {
         if (!IsHex(request.params[paramIdx + 6].get_str())) {
@@ -760,7 +822,7 @@ static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
     }
 
     ptx.keyIDVoting = keyIDVoting;
-    ptx.scriptPayout = GetScriptForDestination(payoutDest);
+    ptx.scriptPayout = ptx.payouts.front().scriptPayout;
 
     if (action != ProTxRegisterAction::Fund) {
         // make sure fee calculation works
@@ -1073,7 +1135,8 @@ static UniValue protx_update_service_common_wrapper(const JSONRPCRequest& reques
             ExtractDestination(ptx.scriptOperatorPayout, feeSource);
         } else {
             // use payout address as default source for fees
-            ExtractDestination(dmn->pdmnState->scriptPayout, feeSource);
+            const auto owner_payouts = GetOwnerPayouts(dmn->pdmnState->nVersion, dmn->pdmnState->scriptPayout, dmn->pdmnState->payouts);
+            ExtractDestination(owner_payouts.front().scriptPayout, feeSource);
         }
     }
 
@@ -1146,9 +1209,13 @@ static RPCHelpMan protx_update_registrar_wrapper(const bool specific_legacy_bls_
     if (!dmn) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("masternode %s not found", ptx.proTxHash.ToString()));
     }
+    if (dmn->pdmnState->nVersion == ProTxVersion::LegacyBLS && ptx.nVersion > ProTxVersion::BasicBLS) {
+        ptx.nVersion = ProTxVersion::BasicBLS;
+    }
 
     ptx.keyIDVoting = dmn->pdmnState->keyIDVoting;
     ptx.scriptPayout = dmn->pdmnState->scriptPayout;
+    ptx.payouts = GetOwnerPayouts(dmn->pdmnState->nVersion, dmn->pdmnState->scriptPayout, dmn->pdmnState->payouts);
 
     if (!request.params[1].get_str().empty()) {
         // new pubkey
@@ -1165,13 +1232,16 @@ static RPCHelpMan protx_update_registrar_wrapper(const bool specific_legacy_bls_
     }
 
     CTxDestination payoutDest;
-    ExtractDestination(ptx.scriptPayout, payoutDest);
-    if (!request.params[3].get_str().empty()) {
-        payoutDest = DecodeDestination(request.params[3].get_str());
-        if (!IsValidDestination(payoutDest)) {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("invalid payout address: %s", request.params[3].get_str()));
+    ExtractDestination(ptx.payouts.front().scriptPayout, payoutDest);
+    if (request.params[3].isArray()) {
+        if (ptx.nVersion < ProTxVersion::MultiPayout) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "payouts array requires provider transaction version 4");
         }
-        ptx.scriptPayout = GetScriptForDestination(payoutDest);
+        ptx.payouts = ParsePayouts(request.params[3], "payouts", payoutDest);
+        ptx.scriptPayout = ptx.payouts.front().scriptPayout;
+    } else if (!request.params[3].get_str().empty()) {
+        ptx.payouts = ParsePayouts(request.params[3], "payouts", payoutDest);
+        ptx.scriptPayout = ptx.payouts.front().scriptPayout;
     }
 
     {
@@ -1302,13 +1372,14 @@ static RPCHelpMan protx_revoke()
         CTxDestination txDest;
         ExtractDestination(dmn->pdmnState->scriptOperatorPayout, txDest);
         FundSpecialTx(*pwallet, tx, ptx, txDest);
-    } else if (dmn->pdmnState->scriptPayout != CScript()) {
+    } else {
         // Using funds from previousely specified masternode payout address
         CTxDestination txDest;
-        ExtractDestination(dmn->pdmnState->scriptPayout, txDest);
+        const auto owner_payouts = GetOwnerPayouts(dmn->pdmnState->nVersion, dmn->pdmnState->scriptPayout, dmn->pdmnState->payouts);
+        if (owner_payouts.empty() || !ExtractDestination(owner_payouts.front().scriptPayout, txDest)) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "No payout or fee source addresses found, can't revoke");
+        }
         FundSpecialTx(*pwallet, tx, ptx, txDest);
-    } else {
-        throw JSONRPCError(RPC_INTERNAL_ERROR, "No payout or fee source addresses found, can't revoke");
     }
 
     bool fSubmit{true};
@@ -1334,6 +1405,14 @@ static bool CheckWalletOwnsScript(const CWallet* const pwallet, const CScript& s
     return WITH_LOCK(pwallet->cs_wallet, return pwallet->IsMine(script)) == isminetype::ISMINE_SPENDABLE;
 }
 
+static bool CheckWalletOwnsAnyPayout(const CWallet* const pwallet, const CDeterministicMNState& state)
+{
+    for (const auto& payout : GetOwnerPayouts(state.nVersion, state.scriptPayout, state.payouts)) {
+        if (CheckWalletOwnsScript(pwallet, payout.scriptPayout)) return true;
+    }
+    return false;
+}
+
 static bool CheckWalletOwnsKey(const CWallet* const pwallet, const CKeyID& keyID) {
     return CheckWalletOwnsScript(pwallet, GetScriptForDestination(PKHash(keyID)));
 }
@@ -1381,7 +1460,7 @@ static UniValue BuildDMNListEntry(const CWallet* const pwallet, const CDetermini
         walletObj.pushKV("hasOperatorKey", false);
         walletObj.pushKV("hasVotingKey", hasVotingKey);
         walletObj.pushKV("ownsCollateral", ownsCollateral);
-        walletObj.pushKV("ownsPayeeScript", CheckWalletOwnsScript(pwallet, dmn.pdmnState->scriptPayout));
+        walletObj.pushKV("ownsPayeeScript", CheckWalletOwnsAnyPayout(pwallet, *dmn.pdmnState));
         walletObj.pushKV("ownsOperatorRewardScript", CheckWalletOwnsScript(pwallet, dmn.pdmnState->scriptOperatorPayout));
         o.pushKV("wallet", walletObj);
     }
@@ -1477,7 +1556,7 @@ static RPCHelpMan protx_list()
             if (setOutpts.count(dmn.collateralOutpoint) ||
                 CheckWalletOwnsKey(wallet.get(), dmn.pdmnState->keyIDOwner) ||
                 CheckWalletOwnsKey(wallet.get(), dmn.pdmnState->keyIDVoting) ||
-                CheckWalletOwnsScript(wallet.get(), dmn.pdmnState->scriptPayout) ||
+                CheckWalletOwnsAnyPayout(wallet.get(), *dmn.pdmnState) ||
                 CheckWalletOwnsScript(wallet.get(), dmn.pdmnState->scriptOperatorPayout)) {
                 ret.push_back(BuildDMNListEntry(wallet.get(), dmn, mn_metaman, detailed, chainman));
             }
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index 14e940b61136..f77c1329d2d2 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -228,12 +228,18 @@ static std::string GetRequiredPaymentsString(governance::SuperblockManager& supe
 {
     std::string strPayments = "Unknown";
     if (payee) {
-        CTxDestination dest;
-        if (!ExtractDestination(payee->pdmnState->scriptPayout, dest)) {
-            NONFATAL_UNREACHABLE();
+        strPayments.clear();
+        for (const auto& payout : GetOwnerPayouts(payee->pdmnState->nVersion, payee->pdmnState->scriptPayout,
+                                                  payee->pdmnState->payouts)) {
+            CTxDestination dest;
+            if (!ExtractDestination(payout.scriptPayout, dest)) {
+                NONFATAL_UNREACHABLE();
+            }
+            if (!strPayments.empty()) strPayments += ", ";
+            strPayments += EncodeDestination(dest);
         }
-        strPayments = EncodeDestination(dest);
         if (payee->nOperatorReward != 0 && payee->pdmnState->scriptOperatorPayout != CScript()) {
+            CTxDestination dest;
             if (!ExtractDestination(payee->pdmnState->scriptOperatorPayout, dest)) {
                 NONFATAL_UNREACHABLE();
             }
@@ -260,6 +266,20 @@ static std::string GetRequiredPaymentsString(governance::SuperblockManager& supe
     return strPayments;
 }
 
+static std::string GetOwnerPayoutsString(const CDeterministicMNState& state)
+{
+    std::string str_payees;
+    for (const auto& payout : GetOwnerPayouts(state.nVersion, state.scriptPayout, state.payouts)) {
+        CTxDestination dest;
+        if (!ExtractDestination(payout.scriptPayout, dest)) {
+            NONFATAL_UNREACHABLE();
+        }
+        if (!str_payees.empty()) str_payees += ", ";
+        str_payees += EncodeDestination(dest);
+    }
+    return str_payees.empty() ? "UNKNOWN" : str_payees;
+}
+
 static RPCHelpMan masternode_winners()
 {
     return RPCHelpMan{"masternode winners",
@@ -632,12 +652,7 @@ static RPCHelpMan masternodelist_helper(bool is_composite)
             }
         }
 
-        CScript payeeScript = dmn.pdmnState->scriptPayout;
-        CTxDestination payeeDest;
-        std::string payeeStr = "UNKNOWN";
-        if (ExtractDestination(payeeScript, payeeDest)) {
-            payeeStr = EncodeDestination(payeeDest);
-        }
+        const std::string payeeStr = GetOwnerPayoutsString(*dmn.pdmnState);
 
         std::string strAddress{};
         if (strMode == "addr" || strMode == "full" || strMode == "info" || strMode == "json" || strMode == "recent" ||
diff --git a/src/test/evo_deterministicmns_tests.cpp b/src/test/evo_deterministicmns_tests.cpp
index af286a51f148..3af64daa6347 100644
--- a/src/test/evo_deterministicmns_tests.cpp
+++ b/src/test/evo_deterministicmns_tests.cpp
@@ -419,6 +419,252 @@ void FuncV19Activation(TestChainSetup& setup)
     BOOST_REQUIRE(dummy_list == tip_list);
 };
 
+void FuncProUpRegTxVersionHandlingBeforeV24(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());
+
+    BOOST_REQUIRE(!DeploymentActiveAfter(chainman.ActiveChain().Tip(), chainman.GetConsensus(), Consensus::DEPLOYMENT_V19));
+    BOOST_REQUIRE(bls::bls_legacy_scheme.load());
+
+    auto utxos = BuildSimpleUtxoMap(setup.m_coinbase_txns);
+    CKey owner_key;
+    CBLSSecretKey operator_key;
+    auto tx_reg = CreateProRegTx(chainman.ActiveChain(), *(setup.m_node.mempool), utxos, 1, GenerateRandomAddress(),
+                                 setup.coinbaseKey, owner_key, operator_key);
+    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::LegacyBLS);
+
+    while (!DeploymentActiveAfter(chainman.ActiveChain().Tip(), chainman.GetConsensus(), Consensus::DEPLOYMENT_V19)) {
+        setup.CreateAndProcessBlock({}, coinbase_pk);
+        dmnman.UpdatedBlockTip(chainman.ActiveChain().Tip());
+    }
+    BOOST_REQUIRE(!DeploymentActiveAfter(chainman.ActiveChain().Tip(), chainman, Consensus::DEPLOYMENT_V24));
+    BOOST_REQUIRE(!bls::bls_legacy_scheme.load());
+
+    const auto payoutScript = GenerateRandomAddress();
+    auto tx_upreg = CreateProUpRegTx(chainman.ActiveChain(), *(setup.m_node.mempool), utxos, proTxHash, owner_key,
+                                     operator_key.GetPublicKey(), owner_key.GetPubKey().GetID(), payoutScript,
+                                     setup.coinbaseKey);
+    const auto opt_upreg = GetTxPayload<CProUpRegTx>(tx_upreg);
+    BOOST_REQUIRE(opt_upreg);
+    BOOST_CHECK_EQUAL(opt_upreg->nVersion, ProTxVersion::BasicBLS);
+
+    setup.CreateAndProcessBlock({tx_upreg}, coinbase_pk);
+    dmnman.UpdatedBlockTip(chainman.ActiveChain().Tip());
+
+    dmn = dmnman.GetListAtChainTip().GetMN(proTxHash);
+    BOOST_REQUIRE(dmn);
+    BOOST_CHECK(dmn->pdmnState->scriptPayout == payoutScript);
+    BOOST_CHECK_EQUAL(dmn->pdmnState->nVersion, ProTxVersion::LegacyBLS);
+    BOOST_REQUIRE(!dmn->pdmnState->IsBanned());
+
+    CBLSSecretKey operator_key_new;
+    operator_key_new.MakeNewKey();
+    const auto payoutScript2 = GenerateRandomAddress();
+    auto tx_upreg2 = CreateProUpRegTx(chainman.ActiveChain(), *(setup.m_node.mempool), utxos, proTxHash, owner_key,
+                                      operator_key_new.GetPublicKey(), owner_key.GetPubKey().GetID(), payoutScript2,
+                                      setup.coinbaseKey);
+    setup.CreateAndProcessBlock({tx_upreg2}, coinbase_pk);
+    dmnman.UpdatedBlockTip(chainman.ActiveChain().Tip());
+
+    dmn = dmnman.GetListAtChainTip().GetMN(proTxHash);
+    BOOST_REQUIRE(dmn);
+    BOOST_CHECK(dmn->pdmnState->scriptPayout == payoutScript2);
+    BOOST_CHECK_EQUAL(dmn->pdmnState->nVersion, ProTxVersion::BasicBLS);
+    BOOST_CHECK(!dmn->pdmnState->pubKeyOperator.IsLegacy());
+    BOOST_REQUIRE(dmn->pdmnState->IsBanned());
+
+    CBLSSecretKey operator_key_legacy;
+    operator_key_legacy.MakeNewKey();
+    const auto payoutScript3 = GenerateRandomAddress();
+    CProUpRegTx proTxLegacy;
+    proTxLegacy.nVersion = ProTxVersion::LegacyBLS;
+    proTxLegacy.proTxHash = proTxHash;
+    proTxLegacy.pubKeyOperator.Set(operator_key_legacy.GetPublicKey(), /*legacy=*/true);
+    proTxLegacy.keyIDVoting = owner_key.GetPubKey().GetID();
+    proTxLegacy.scriptPayout = payoutScript3;
+
+    CMutableTransaction tx_upreg3;
+    tx_upreg3.nVersion = 3;
+    tx_upreg3.nType = TRANSACTION_PROVIDER_UPDATE_REGISTRAR;
+    FundTransaction(chainman.ActiveChain(), tx_upreg3, utxos, GetScriptForDestination(PKHash(setup.coinbaseKey.GetPubKey())),
+                    1 * COIN, setup.coinbaseKey);
+    proTxLegacy.inputsHash = CalcTxInputsHash(CTransaction(tx_upreg3));
+    CHashSigner::SignHash(::SerializeHash(proTxLegacy), owner_key, proTxLegacy.vchSig);
+    SetTxPayload(tx_upreg3, proTxLegacy);
+    SignTransaction(*(setup.m_node.mempool), tx_upreg3, setup.coinbaseKey);
+
+    setup.CreateAndProcessBlock({tx_upreg3}, coinbase_pk);
+    dmnman.UpdatedBlockTip(chainman.ActiveChain().Tip());
+
+    dmn = dmnman.GetListAtChainTip().GetMN(proTxHash);
+    BOOST_REQUIRE(dmn);
+    BOOST_CHECK(dmn->pdmnState->scriptPayout == payoutScript3);
+    // Pre-v24, an operator-changing registrar update adopts the tx version even when that lowers the
+    // stored version: the v1 update downgrades the state to LegacyBLS and re-encodes the new operator
+    // key with the legacy scheme. This must match already-deployed consensus; version-bump hardening
+    // only applies once v24 is active.
+    BOOST_CHECK_EQUAL(dmn->pdmnState->nVersion, ProTxVersion::LegacyBLS);
+    BOOST_CHECK(dmn->pdmnState->pubKeyOperator.IsLegacy());
+    BOOST_CHECK(dmn->pdmnState->pubKeyOperator.Get() == operator_key_legacy.GetPublicKey());
+};
+
+void FuncProUpRegTxV4OnLegacyRejected(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());
+
+    BOOST_REQUIRE(!DeploymentActiveAfter(chainman.ActiveChain().Tip(), chainman.GetConsensus(), Consensus::DEPLOYMENT_V19));
+    BOOST_REQUIRE(!DeploymentActiveAfter(chainman.ActiveChain().Tip(), chainman, Consensus::DEPLOYMENT_V24));
+
+    auto utxos = BuildSimpleUtxoMap(setup.m_coinbase_txns);
+    CKey owner_key;
+    CBLSSecretKey operator_key;
+    auto tx_reg = CreateProRegTx(chainman.ActiveChain(), *(setup.m_node.mempool), utxos, 1, GenerateRandomAddress(),
+                                 setup.coinbaseKey, owner_key, operator_key);
+    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::LegacyBLS);
+
+    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.GetConsensus(), Consensus::DEPLOYMENT_V19));
+    BOOST_REQUIRE(DeploymentActiveAfter(chainman.ActiveChain().Tip(), chainman, Consensus::DEPLOYMENT_V24));
+    BOOST_REQUIRE(!bls::bls_legacy_scheme.load());
+    BOOST_REQUIRE_EQUAL(dmnman.GetListAtChainTip().GetMN(proTxHash)->pdmnState->nVersion, ProTxVersion::LegacyBLS);
+
+    CProUpRegTx proTx;
+    proTx.nVersion = ProTxVersion::MultiPayout;
+    proTx.proTxHash = proTxHash;
+    proTx.pubKeyOperator.Set(operator_key.GetPublicKey(), bls::bls_legacy_scheme.load());
+    proTx.keyIDVoting = owner_key.GetPubKey().GetID();
+    proTx.payouts = {{GenerateRandomAddress(), CMasternodePayoutShare::MAX_REWARD}};
+
+    CMutableTransaction tx;
+    tx.nVersion = 3;
+    tx.nType = TRANSACTION_PROVIDER_UPDATE_REGISTRAR;
+    FundTransaction(chainman.ActiveChain(), tx, utxos, GetScriptForDestination(PKHash(setup.coinbaseKey.GetPubKey())),
+                    1 * COIN, setup.coinbaseKey);
+    proTx.inputsHash = CalcTxInputsHash(CTransaction(tx));
+    CHashSigner::SignHash(::SerializeHash(proTx), owner_key, proTx.vchSig);
+    SetTxPayload(tx, proTx);
+    SignTransaction(*(setup.m_node.mempool), tx, setup.coinbaseKey);
+
+    TxValidationState val_state;
+    {
+        LOCK(cs_main);
+        BOOST_CHECK(!CheckProUpRegTx(CTransaction(tx), chainman.ActiveChain().Tip(), dmnman,
+                                     chainman.ActiveChainstate().CoinsTip(), chainman, val_state, /*check_sigs=*/true));
+    }
+    BOOST_CHECK_EQUAL(val_state.GetRejectReason(), "bad-protx-version-upgrade");
+};
+
+void FuncProUpRegTxV2CannotBypassV4PayoutCollateralReuse(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());
+
+    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.GetConsensus(), 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);
+    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()));
+    const auto script_payout = GenerateRandomAddress();
+
+    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());
+
+    CProRegTx pro_reg;
+    pro_reg.nVersion = ProTxVersion::MultiPayout;
+    pro_reg.netInfo = NetInfoInterface::MakeNetInfo(pro_reg.nVersion);
+    BOOST_CHECK_EQUAL(pro_reg.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:9999"), 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.payouts = {{script_payout, CMasternodePayoutShare::MAX_REWARD}};
+    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::MultiPayout);
+    BOOST_CHECK_EQUAL(dmn->pdmnState->payouts.size(), 1U);
+    BOOST_CHECK(dmn->pdmnState->payouts.front().scriptPayout == script_payout);
+
+    CProUpRegTx pro_upreg;
+    pro_upreg.nVersion = ProTxVersion::BasicBLS;
+    pro_upreg.proTxHash = proTxHash;
+    pro_upreg.pubKeyOperator.Set(operator_key.GetPublicKey(), bls::bls_legacy_scheme.load());
+    pro_upreg.keyIDVoting = owner_key.GetPubKey().GetID();
+    pro_upreg.scriptPayout = script_collateral;
+
+    CMutableTransaction tx_upreg;
+    tx_upreg.nVersion = 3;
+    tx_upreg.nType = TRANSACTION_PROVIDER_UPDATE_REGISTRAR;
+    FundTransaction(chainman.ActiveChain(), tx_upreg, utxos, GetScriptForDestination(PKHash(setup.coinbaseKey.GetPubKey())),
+                    1 * COIN, setup.coinbaseKey);
+    pro_upreg.inputsHash = CalcTxInputsHash(CTransaction(tx_upreg));
+    CHashSigner::SignHash(::SerializeHash(pro_upreg), owner_key, pro_upreg.vchSig);
+    SetTxPayload(tx_upreg, pro_upreg);
+    SignTransaction(*(setup.m_node.mempool), tx_upreg, setup.coinbaseKey);
+
+    TxValidationState val_state;
+    {
+        LOCK(cs_main);
+        BOOST_CHECK(!CheckProUpRegTx(CTransaction(tx_upreg), chainman.ActiveChain().Tip(), dmnman,
+                                     chainman.ActiveChainstate().CoinsTip(), chainman, val_state, /*check_sigs=*/true));
+    }
+    BOOST_CHECK_EQUAL(val_state.GetRejectReason(), "bad-protx-payee-reuse");
+}
+
 void FuncDIP3Protx(TestChainSetup& setup)
 {
     auto& chainman = *Assert(setup.m_node.chainman.get());
@@ -976,6 +1222,20 @@ TestChainV19BeforeActivationSetup::TestChainV19BeforeActivationSetup() :
     assert(!v19_active);
 }
 
+struct TestChainV24SignalBeforeV19Setup : public TestChainSetup {
+    TestChainV24SignalBeforeV19Setup() :
+        TestChainSetup(494, CBaseChainParams::REGTEST,
+                       {"-testactivationheight=v19@500", "-testactivationheight=v20@500",
+                        "-testactivationheight=mn_rr@500",
+                        "-vbparams=v24:0:9999999999:0:500:400:300:5:0"})
+    {
+        assert(!DeploymentActiveAfter(m_node.chainman->ActiveChain().Tip(), m_node.chainman->GetConsensus(),
+                                      Consensus::DEPLOYMENT_V19));
+        assert(!DeploymentActiveAfter(m_node.chainman->ActiveChain().Tip(), *m_node.chainman,
+                                      Consensus::DEPLOYMENT_V24));
+    }
+};
+
 // DIP3 can only be activated with legacy scheme (v19 is activated later)
 BOOST_AUTO_TEST_CASE(dip3_activation_legacy)
 {
@@ -990,6 +1250,24 @@ BOOST_AUTO_TEST_CASE(v19_activation_legacy)
     FuncV19Activation(setup);
 }
 
+BOOST_AUTO_TEST_CASE(proupreg_version_handling_before_v24)
+{
+    TestChainV19BeforeActivationSetup setup;
+    FuncProUpRegTxVersionHandlingBeforeV24(setup);
+}
+
+BOOST_AUTO_TEST_CASE(proupreg_v4_on_legacy_rejected)
+{
+    TestChainV24SignalBeforeV19Setup setup;
+    FuncProUpRegTxV4OnLegacyRejected(setup);
+}
+
+BOOST_AUTO_TEST_CASE(proupreg_v2_cannot_bypass_v4_payout_collateral_reuse)
+{
+    TestChainV24SignalBeforeV19Setup setup;
+    FuncProUpRegTxV2CannotBypassV4PayoutCollateralReuse(setup);
+}
+
 BOOST_AUTO_TEST_CASE(dip3_protx_legacy)
 {
     TestChainDIP3Setup setup;
diff --git a/src/test/evo_trivialvalidation.cpp b/src/test/evo_trivialvalidation.cpp
index 74da999581b2..1e47c3f9dfa2 100644
--- a/src/test/evo_trivialvalidation.cpp
+++ b/src/test/evo_trivialvalidation.cpp
@@ -11,7 +11,10 @@
 #include <chainparams.h>
 #include <deploymentstatus.h>
 #include <evo/providertx.h>
+#include <key.h>
 #include <primitives/transaction.h>
+#include <script/script.h>
+#include <script/standard.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
@@ -132,4 +135,69 @@ BOOST_AUTO_TEST_CASE(trivialvalidation_invalid)
     trivialvalidation_runner(*m_node.chainman, json);
 }
 
+static CScript NewP2PKHScript(CKey& key)
+{
+    key.MakeNewKey(true);
+    return GetScriptForDestination(PKHash(key.GetPubKey()));
+}
+
+static void CheckPayouts(const MasternodePayoutShares& payouts, const CKeyID& owner, const CKeyID& voting,
+                         const std::optional<std::string>& expected_error)
+{
+    TxValidationState state;
+    BOOST_CHECK_EQUAL(IsPayoutListTriviallyValid(payouts, owner, voting, state), !expected_error.has_value());
+    if (expected_error.has_value()) {
+        BOOST_CHECK_EQUAL(state.GetRejectReason(), *expected_error);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(multipayout_list_validation)
+{
+    CKey owner_key, voting_key, payout_key1, payout_key2, payout_key3;
+    const CScript payout1 = NewP2PKHScript(payout_key1);
+    const CScript payout2 = NewP2PKHScript(payout_key2);
+    const CScript payout3 = NewP2PKHScript(payout_key3);
+    owner_key.MakeNewKey(true);
+    voting_key.MakeNewKey(true);
+    const CKeyID owner_id = owner_key.GetPubKey().GetID();
+    const CKeyID voting_id = voting_key.GetPubKey().GetID();
+
+    CheckPayouts({{payout1, 10000}}, owner_id, voting_id, std::nullopt);
+    CheckPayouts({{payout1, 5000}, {payout2, 3000}, {payout3, 2000}}, owner_id, voting_id, std::nullopt);
+    CheckPayouts({}, owner_id, voting_id, "bad-protx-payouts-count");
+
+    MasternodePayoutShares too_many;
+    for (int i = 0; i < 9; ++i) {
+        CKey key;
+        too_many.emplace_back(NewP2PKHScript(key), 1000);
+    }
+    CheckPayouts(too_many, owner_id, voting_id, "bad-protx-payouts-count");
+
+    CheckPayouts({{payout1, 99}, {payout2, 9901}}, owner_id, voting_id, "bad-protx-payout-reward");
+    CheckPayouts({{payout1, CMasternodePayoutShare::MAX_REWARD + 1}}, owner_id, voting_id, "bad-protx-payout-reward");
+    CheckPayouts({{payout1, 5000}, {payout2, 4999}}, owner_id, voting_id, "bad-protx-payout-reward-sum");
+    CheckPayouts({{payout1, 5000}, {payout1, 5000}}, owner_id, voting_id, "bad-protx-payee-dup");
+    CheckPayouts({{CScript() << OP_RETURN, 10000}}, owner_id, voting_id, "bad-protx-payee");
+    CheckPayouts({{GetScriptForDestination(PKHash(owner_id)), 10000}}, owner_id, voting_id, "bad-protx-payee-reuse");
+    CheckPayouts({{GetScriptForDestination(PKHash(voting_id)), 10000}}, owner_id, voting_id, "bad-protx-payee-reuse");
+    CheckPayouts({{GetScriptForDestination(PKHash(CKeyID{})), 10000}}, CKeyID{}, voting_id, std::nullopt);
+    CheckPayouts({{GetScriptForDestination(PKHash(voting_id)), 10000}}, CKeyID{}, voting_id, "bad-protx-payee-reuse");
+
+    TxValidationState state;
+    BOOST_CHECK(!IsPayoutListKeySafe({{payout1, 10000}}, CTxDestination(PKHash(payout_key1.GetPubKey().GetID())),
+                                     owner_id, voting_id, /*check_payout_collateral_reuse=*/true, state));
+    BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-protx-payee-reuse");
+    state = TxValidationState{};
+    BOOST_CHECK(IsPayoutListKeySafe({{payout1, 10000}}, CTxDestination(PKHash(payout_key1.GetPubKey().GetID())),
+                                    owner_id, voting_id, /*check_payout_collateral_reuse=*/false, state));
+
+    CScript p2sh_collateral = GetScriptForDestination(ScriptHash(payout1));
+    CTxDestination p2sh_dest;
+    BOOST_CHECK(ExtractDestination(p2sh_collateral, p2sh_dest));
+    state = TxValidationState{};
+    BOOST_CHECK(!IsPayoutListKeySafe({{p2sh_collateral, 10000}}, p2sh_dest, owner_id, voting_id,
+                                     /*check_payout_collateral_reuse=*/true, state));
+    BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-protx-payee-reuse");
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/functional/feature_masternode_payout_shares.py b/test/functional/feature_masternode_payout_shares.py
new file mode 100755
index 000000000000..6a1910835702
--- /dev/null
+++ b/test/functional/feature_masternode_payout_shares.py
@@ -0,0 +1,247 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 The Dash Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test v4 masternode owner payout shares."""
+
+from test_framework.blocktools import create_block, create_coinbase
+from test_framework.messages import CTxOut, tx_from_hex
+from test_framework.script import CScript
+from test_framework.test_framework import DashTestFramework, MasternodeInfo, p2p_port
+from test_framework.util import assert_equal, softfork_active
+
+V24_ACTIVATION_THRESHOLD = 100
+
+
+def payout_address_rewards(payouts):
+    return [{"address": p["address"], "reward": p["reward"]} for p in payouts]
+
+
+class MasternodePayoutSharesTest(DashTestFramework):
+    def add_options(self, parser):
+        self.add_wallet_options(parser)
+
+    def set_test_params(self):
+        self.set_dash_test_params(1, 0, extra_args=[[
+            f"-vbparams=v24:{self.mocktime}:999999999999:{V24_ACTIVATION_THRESHOLD}:10:8:6:5:0",
+        ]])
+
+    def activate_v24(self):
+        while not softfork_active(self.nodes[0], "v24"):
+            self.bump_mocktime(50)
+            self.generate(self.nodes[0], 50, sync_fun=self.no_op)
+        assert softfork_active(self.nodes[0], "v24")
+
+    def build_block(self, node, tamper=None):
+        """Build a block extending the tip whose coinbase pays exactly the template's
+        masternode payouts, optionally mutated by ``tamper(coinbase)`` before solving."""
+        bt = node.getblocktemplate()
+        tip_hash = bt["previousblockhash"]
+
+        coinbase = create_coinbase(bt["height"])
+        coinbase.vout = []
+        mn_total = 0
+        for payee in bt["masternode"]:
+            coinbase.vout.append(CTxOut(payee["amount"], CScript(bytes.fromhex(payee["script"]))))
+            mn_total += payee["amount"]
+        miner_addr = node.get_deterministic_priv_key().address
+        miner_script = CScript(bytes.fromhex(node.getaddressinfo(miner_addr)["scriptPubKey"]))
+        coinbase.vout.append(CTxOut(bt["coinbasevalue"] - mn_total, miner_script))
+
+        # The CbTx payload's Merkle roots don't depend on the coinbase outputs (the payee
+        # selection is unchanged by our tampering), so reuse the template's payload verbatim.
+        coinbase.nVersion = 3
+        coinbase.nType = 5  # CbTx
+        coinbase.vExtraPayload = bytes.fromhex(bt["coinbase_payload"])
+
+        if tamper is not None:
+            tamper(coinbase)
+        # create_coinbase() already cached a txid; rehash so it reflects our rewritten outputs.
+        coinbase.rehash()
+
+        block = create_block(int(tip_hash, 16), coinbase, ntime=bt["curtime"], version=bt["version"])
+        # Quorum commitments from the template are mandatory in the block.
+        for tx_obj in bt["transactions"]:
+            tx = tx_from_hex(tx_obj["data"])
+            if tx.nType == 6:
+                block.vtx.append(tx)
+        block.hashMerkleRoot = block.calc_merkle_root()
+        block.solve()
+        return block
+
+    def run_test(self):
+        node = self.nodes[0]
+        self.activate_v24()
+
+        mn = MasternodeInfo(evo=False, legacy=False)
+        mn.generate_addresses(node)
+        mn.nodePort = p2p_port(1)
+
+        payout1 = node.getnewaddress()
+        payout2 = node.getnewaddress()
+        payouts = [
+            {"address": payout1, "reward": 7000},
+            {"address": payout2, "reward": 3000},
+        ]
+
+        collateral_txid = node.sendmany("", {mn.collateral_address: mn.get_collateral_value(), mn.fundsAddr: 1})
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        mn.collateral_txid = collateral_txid
+        mn.collateral_vout = mn.get_collateral_vout(node, collateral_txid)
+
+        mn.register(
+            node,
+            submit=True,
+            collateral_txid=mn.collateral_txid,
+            collateral_vout=mn.collateral_vout,
+            addrs_core_p2p=[f"127.0.0.1:{mn.nodePort}"],
+            operator_reward=0,
+            payouts=[],
+            fundsAddr=mn.fundsAddr,
+            expected_assert_code=-8,
+            expected_assert_msg="payouts must contain at least one entry",
+        )
+
+        protx_hash = mn.register(
+            node,
+            submit=True,
+            collateral_txid=mn.collateral_txid,
+            collateral_vout=mn.collateral_vout,
+            addrs_core_p2p=[f"127.0.0.1:{mn.nodePort}"],
+            operator_reward=25,
+            payouts=payouts,
+            fundsAddr=mn.fundsAddr,
+        )
+        assert protx_hash is not None
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        mn.set_params(proTxHash=protx_hash)
+
+        raw = node.getrawtransaction(protx_hash, 1)
+        assert_equal(raw["proRegTx"]["version"], 4)
+        assert_equal(payout_address_rewards(raw["proRegTx"]["payouts"]), payouts)
+
+        info = node.protx("info", protx_hash)
+        assert_equal(info["state"]["version"], 4)
+        assert_equal(payout_address_rewards(info["state"]["payouts"]), payouts)
+        assert "payoutAddress" not in info["state"]
+        assert_equal(node.masternodelist("payee")[f"{mn.collateral_txid}-{mn.collateral_vout}"], f"{payout1}, {payout2}")
+
+        mn.update_registrar(
+            node,
+            submit=True,
+            payouts=[],
+            fundsAddr=mn.fundsAddr,
+            expected_assert_code=-8,
+            expected_assert_msg="payouts must contain at least one entry",
+        )
+
+        gbt_payees = [p for p in node.getblocktemplate()["masternode"] if p["script"] != "6a"]
+        assert_equal(len(gbt_payees), 2)
+        assert_equal(gbt_payees[0]["payee"], payout1)
+        assert_equal(gbt_payees[1]["payee"], payout2)
+        owner_total = sum(p["amount"] for p in gbt_payees)
+        assert_equal(gbt_payees[0]["amount"], owner_total * 7000 // 10000)
+        assert_equal(gbt_payees[1]["amount"], owner_total - gbt_payees[0]["amount"])
+
+        self.generate(node, 1, sync_fun=self.no_op)
+        payments = node.masternode("payments")[0]["masternodes"][0]["payees"]
+        payment_payees = [p for p in payments if p["script"] != "6a"]
+        assert_equal([p["address"] for p in payment_payees], [payout1, payout2])
+
+        # DIP-0026 cases 13 & 14: coinbase validation must reject a block that omits an
+        # expected owner payout output or pays one the wrong amount. A faithful coinbase
+        # is accepted, proving the rejections below are caused by the tampering itself.
+        payout1_script = CScript(bytes.fromhex(node.getaddressinfo(payout1)["scriptPubKey"]))
+        payout2_script = CScript(bytes.fromhex(node.getaddressinfo(payout2)["scriptPubKey"]))
+
+        def drop_payout1(coinbase):
+            coinbase.vout = [out for out in coinbase.vout if out.scriptPubKey != payout1_script]
+
+        def shortpay_payout2(coinbase):
+            for out in coinbase.vout:
+                if out.scriptPubKey == payout2_script:
+                    out.nValue -= 1
+
+        assert_equal(node.submitblock(self.build_block(node, drop_payout1).serialize().hex()), "bad-cb-payee")
+        assert_equal(node.submitblock(self.build_block(node, shortpay_payout2).serialize().hex()), "bad-cb-payee")
+        assert_equal(node.submitblock(self.build_block(node).serialize().hex()), None)
+
+        updated_payouts = [{"address": node.getnewaddress(), "reward": 1250} for _ in range(8)]
+        node.sendtoaddress(mn.fundsAddr, 1)
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        update_hash = mn.update_registrar(node, submit=True, payouts=updated_payouts, fundsAddr=mn.fundsAddr)
+        assert update_hash is not None
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+
+        update_raw = node.getrawtransaction(update_hash, 1)
+        assert_equal(update_raw["proUpRegTx"]["version"], 4)
+        assert_equal(payout_address_rewards(update_raw["proUpRegTx"]["payouts"]), updated_payouts)
+        assert_equal(payout_address_rewards(node.protx("info", protx_hash)["state"]["payouts"]), updated_payouts)
+
+        operator_payout = node.getnewaddress()
+        node.sendtoaddress(mn.fundsAddr, 1)
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        service_hash = mn.update_service(
+            node,
+            submit=True,
+            addrs_core_p2p=[f"127.0.0.2:{mn.nodePort}"],
+            address_operator=operator_payout,
+            fundsAddr=mn.fundsAddr,
+        )
+        assert service_hash is not None
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+
+        info = node.protx("info", protx_hash)
+        assert_equal(info["state"]["version"], 4)
+        assert_equal(payout_address_rewards(info["state"]["payouts"]), updated_payouts)
+
+        gbt_payees = [p for p in node.getblocktemplate()["masternode"] if p["script"] != "6a"]
+        operator_payees = [p for p in gbt_payees if p["payee"] == operator_payout]
+        assert_equal(len(operator_payees), 1)
+        owner_payees = [p for p in gbt_payees if p["payee"] != operator_payout]
+        assert_equal([p["payee"] for p in owner_payees], [p["address"] for p in updated_payouts])
+        masternode_total = sum(p["amount"] for p in gbt_payees)
+        operator_amount = masternode_total * 2500 // 10000
+        assert_equal(operator_payees[0]["amount"], operator_amount)
+        owner_total = masternode_total - operator_amount
+        paid_owner_total = 0
+        for i, payee in enumerate(owner_payees):
+            expected_amount = owner_total - paid_owner_total if i == len(owner_payees) - 1 else owner_total * 1250 // 10000
+            assert_equal(payee["amount"], expected_amount)
+            paid_owner_total += payee["amount"]
+
+        self.generate(node, 1, sync_fun=self.no_op)
+        payments = node.masternode("payments")[0]["masternodes"][0]["payees"]
+        payment_payees = [p for p in payments if p["script"] != "6a"]
+        rpc_operator_payees = [p for p in payment_payees if p["address"] == operator_payout]
+        assert_equal(len(rpc_operator_payees), 1)
+        rpc_owner_payees = [p for p in payment_payees if p["address"] != operator_payout]
+        assert_equal([p["address"] for p in rpc_owner_payees], [p["address"] for p in updated_payouts])
+        assert_equal(rpc_operator_payees[0]["amount"], operator_amount)
+        paid_owner_total = 0
+        for i, payee in enumerate(rpc_owner_payees):
+            expected_amount = owner_total - paid_owner_total if i == len(rpc_owner_payees) - 1 else owner_total * 1250 // 10000
+            assert_equal(payee["amount"], expected_amount)
+            paid_owner_total += payee["amount"]
+
+        node.sendtoaddress(mn.fundsAddr, 1)
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+        revoke_hash = mn.revoke(node, submit=True, reason=1, fundsAddr=mn.fundsAddr)
+        assert revoke_hash is not None
+        self.bump_mocktime(10 * 60 + 1)
+        self.generate(node, 1, sync_fun=self.no_op)
+
+        info = node.protx("info", protx_hash)
+        assert_equal(info["state"]["version"], 4)
+        assert_equal(payout_address_rewards(info["state"]["payouts"]), updated_payouts)
+
+
+if __name__ == '__main__':
+    MasternodePayoutSharesTest().main()
diff --git a/test/functional/rpc_netinfo.py b/test/functional/rpc_netinfo.py
index 041f4afa75f2..5349a8e43d76 100755
--- a/test/functional/rpc_netinfo.py
+++ b/test/functional/rpc_netinfo.py
@@ -34,6 +34,7 @@
 # See ProTxVersion in src/evo/providertx.h
 PROTXVER_BASIC = 2
 PROTXVER_EXTADDR = 3
+PROTXVER_MULTIPAYOUT = 4
 
 # Sample domains
 DOMAINS_CLR = [
@@ -524,9 +525,9 @@ def empty_common(grt_dict):
         self.reconnect_nodes()
         self.node_two.register_mn(self, True, "", "", "")
 
-        # Validate that masternode uses extended addresses
+        # Validate that masternode uses the current v24 extended-address-capable payload version
         grt_proregtx = self.node_simple.getrawtransaction(self.node_two.mn.proTxHash, True)['proRegTx']
-        assert_equal(grt_proregtx['version'], PROTXVER_EXTADDR)
+        assert_equal(grt_proregtx['version'], PROTXVER_MULTIPAYOUT)
 
         # Test reporting for extended addresses
         empty_common(grt_proregtx)
diff --git a/test/functional/test_framework/test_framework.py b/test/functional/test_framework/test_framework.py
index d6216c12b9b1..a9fe5d2aeae8 100755
--- a/test/functional/test_framework/test_framework.py
+++ b/test/functional/test_framework/test_framework.py
@@ -1263,7 +1263,8 @@ def validate_inputs(self, platform_node_id: Optional[str] = None, addrs_platform
     def register(self, node: TestNode, submit: bool, collateral_txid: Optional[str] = None, collateral_vout: Optional[int] = None,
                  addrs_core_p2p: Union[str, List[str], None] = None, ownerAddr: Optional[str] = None, pubKeyOperator: Optional[str] = None,
                  votingAddr: Optional[str] = None, operator_reward: Optional[int] = None, rewards_address: Optional[str] = None,
-                 fundsAddr: Optional[str] = None, platform_node_id: Optional[str] = None, addrs_platform_p2p: Union[int, str, List[str], None] = None,
+                 payouts: Optional[List[dict]] = None, fundsAddr: Optional[str] = None,
+                 platform_node_id: Optional[str] = None, addrs_platform_p2p: Union[int, str, List[str], None] = None,
                  addrs_platform_https: Union[int, str, List[str], None] = None, expected_assert_code: Optional[int] = None,
                  expected_assert_msg: Optional[str] = None) -> Optional[str]:
         self.validate_inputs(platform_node_id, addrs_platform_p2p, addrs_platform_https, expected_assert_code, expected_assert_msg)
@@ -1277,7 +1278,7 @@ def register(self, node: TestNode, submit: bool, collateral_txid: Optional[str]
             pubKeyOperator or self.pubKeyOperator,
             votingAddr or self.votingAddr,
             operator_reward or self.operator_reward,
-            rewards_address or self.rewards_address,
+            payouts if payouts is not None else rewards_address or self.rewards_address,
         ]
         address_funds = fundsAddr or self.fundsAddr
 
@@ -1309,7 +1310,8 @@ def register(self, node: TestNode, submit: bool, collateral_txid: Optional[str]
 
     def register_fund(self, node: TestNode, submit: bool, collateral_address: Optional[str] = None, addrs_core_p2p: Union[str, List[str], None] = None,
                       ownerAddr: Optional[str] = None, pubKeyOperator: Optional[str] = None, votingAddr: Optional[str] = None,
-                      operator_reward: Optional[int] = None, rewards_address: Optional[str] = None, fundsAddr: Optional[str] = None,
+                      operator_reward: Optional[int] = None, rewards_address: Optional[str] = None,
+                      payouts: Optional[List[dict]] = None, fundsAddr: Optional[str] = None,
                       platform_node_id: Optional[str] = None, addrs_platform_p2p: Union[int, str, List[str], None] = None,
                       addrs_platform_https: Union[int, str, List[str], None] = None, expected_assert_code: Optional[int] = None,
                       expected_assert_msg: Optional[str] = None) -> Optional[str]:
@@ -1331,7 +1333,7 @@ def register_fund(self, node: TestNode, submit: bool, collateral_address: Option
             pubKeyOperator or self.pubKeyOperator,
             votingAddr or self.votingAddr,
             operator_reward or self.operator_reward,
-            rewards_address or self.rewards_address,
+            payouts if payouts is not None else rewards_address or self.rewards_address,
         ]
         address_funds = fundsAddr or self.fundsAddr
 
@@ -1396,7 +1398,7 @@ def revoke(self, node: TestNode, submit: bool, reason: int, fundsAddr: Optional[
         return ret
 
     def update_registrar(self, node: TestNode, submit: bool, pubKeyOperator: Optional[str] = None, votingAddr: Optional[str] = None,
-                         rewards_address: Optional[str] = None, fundsAddr: Optional[str] = None,
+                         rewards_address: Optional[str] = None, payouts: Optional[List[dict]] = None, fundsAddr: Optional[str] = None,
                          expected_assert_code: Optional[int] = None, expected_assert_msg: Optional[str] = None) -> Optional[str]:
         if (expected_assert_code and not expected_assert_msg) or (not expected_assert_code and expected_assert_msg):
             raise AssertionError("Intending to use assert_raises_rpc_error() but didn't specify code and message")
@@ -1418,7 +1420,7 @@ def update_registrar(self, node: TestNode, submit: bool, pubKeyOperator: Optiona
             self.proTxHash,
             pubKeyOperator or self.pubKeyOperator,
             votingAddr or self.votingAddr,
-            rewards_address or self.rewards_address,
+            payouts if payouts is not None else rewards_address or self.rewards_address,
         ]
 
         # fundsAddr is an optional field that results in different behavior if omitted, so we don't fallback here
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index c328f95d8340..70fa78a36142 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -132,6 +132,7 @@
     'feature_llmq_simplepose.py --disable-spork23', # NOTE: needs dash_hash to pass
     'feature_dip3_deterministicmns.py --legacy-wallet', # NOTE: needs dash_hash to pass
     'feature_dip3_deterministicmns.py --descriptors', # NOTE: needs dash_hash to pass
+    'feature_masternode_payout_shares.py',
     'feature_llmq_signing.py', # NOTE: needs dash_hash to pass
     'feature_llmq_signing.py --spork21', # NOTE: needs dash_hash to pass
     'feature_llmq_rotation.py', # NOTE: needs dash_hash to pass