diff --git a/src/common/bloom.cpp b/src/common/bloom.cpp
index 4b0c4c334f19..b9a17600b6be 100644
--- a/src/common/bloom.cpp
+++ b/src/common/bloom.cpp
@@ -132,7 +132,7 @@ 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 auto owner_payouts = GetOwnerPayouts(*opt_proTx);
             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) ||
@@ -163,7 +163,7 @@ 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 auto owner_payouts = GetOwnerPayouts(*opt_proTx);
             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) ||
diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index 53056d0b9a69..c668f65b0dc5 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -260,7 +260,7 @@ UniValue CDeterministicMNState::ToJson(MnType nType) const
     }
 
     CTxDestination dest;
-    if (nVersion >= ProTxVersion::MultiPayout) {
+    if (nVersion >= ProTxVersion::ExtAddr) {
         obj.pushKV("payouts", PayoutListToJson(payouts));
     } else if (ExtractDestination(scriptPayout, dest)) {
         obj.pushKV("payoutAddress", EncodeDestination(dest));
@@ -335,7 +335,7 @@ UniValue CProRegTx::ToJson() const
     ret.pushKV("addresses", GetNetInfoWithLegacyFields(*this, nType));
     ret.pushKV("ownerAddress", EncodeDestination(PKHash(keyIDOwner)));
     ret.pushKV("votingAddress", EncodeDestination(PKHash(keyIDVoting)));
-    if (nVersion >= ProTxVersion::MultiPayout) {
+    if (nVersion >= ProTxVersion::ExtAddr) {
         ret.pushKV("payouts", PayoutListToJson(payouts));
     } else if (CTxDestination dest; ExtractDestination(scriptPayout, dest)) {
         ret.pushKV("payoutAddress", EncodeDestination(dest));
@@ -373,7 +373,7 @@ UniValue CProUpRegTx::ToJson() const
     ret.pushKV("version", nVersion);
     ret.pushKV("proTxHash", proTxHash.ToString());
     ret.pushKV("votingAddress", EncodeDestination(PKHash(keyIDVoting)));
-    if (nVersion >= ProTxVersion::MultiPayout) {
+    if (nVersion >= ProTxVersion::ExtAddr) {
         ret.pushKV("payouts", PayoutListToJson(payouts));
     } else if (CTxDestination dest; ExtractDestination(scriptPayout, dest)) {
         ret.pushKV("payoutAddress", EncodeDestination(dest));
@@ -582,7 +582,7 @@ UniValue CSimplifiedMNListEntry::ToJson(bool extended) const
 
     if (extended) {
         CTxDestination dest;
-        if (nVersion >= ProTxVersion::MultiPayout) {
+        if (nVersion >= ProTxVersion::ExtAddr) {
             obj.pushKV("payouts", PayoutListToJson(payouts));
         } else if (ExtractDestination(scriptPayout, dest)) {
             obj.pushKV("payoutAddress", EncodeDestination(dest));
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index df22b9198362..20db7a1f08ec 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -45,7 +45,7 @@ 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, GetOwnerPayouts(state.nVersion, state.scriptPayout, state.payouts),
+                                  state.scriptPayout, GetOwnerPayouts(state),
                                   state.scriptOperatorPayout, state.nVersion, nType);
 }
 
diff --git a/src/evo/dmnstate.cpp b/src/evo/dmnstate.cpp
index b384966cb9b7..de22a18c8ede 100644
--- a/src/evo/dmnstate.cpp
+++ b/src/evo/dmnstate.cpp
@@ -16,7 +16,7 @@ std::string CDeterministicMNState::ToString() const
     if (ExtractDestination(scriptPayout, dest)) {
         payoutAddress = EncodeDestination(dest);
     }
-    const auto owner_payouts = GetOwnerPayouts(nVersion, scriptPayout, payouts);
+    const auto owner_payouts = GetOwnerPayouts(*this);
     const std::string payoutList = PayoutListToString(owner_payouts);
     if (ExtractDestination(scriptOperatorPayout, dest)) {
         operatorPayoutAddress = EncodeDestination(dest);
diff --git a/src/evo/dmnstate.h b/src/evo/dmnstate.h
index dfab76d1e25b..7513e6080934 100644
--- a/src/evo/dmnstate.h
+++ b/src/evo/dmnstate.h
@@ -101,7 +101,7 @@ class CDeterministicMNState
             obj.keyIDVoting,
             NetInfoSerWrapper(const_cast<std::shared_ptr<NetInfoInterface>&>(obj.netInfo),
                               obj.nVersion >= ProTxVersion::ExtAddr));
-        if (obj.nVersion >= ProTxVersion::MultiPayout) {
+        if (obj.nVersion >= ProTxVersion::ExtAddr) {
             READWRITE(obj.payouts);
         } else {
             READWRITE(obj.scriptPayout);
diff --git a/src/evo/netinfo.cpp b/src/evo/netinfo.cpp
index a3f53693ccaf..eab2e93a9b16 100644
--- a/src/evo/netinfo.cpp
+++ b/src/evo/netinfo.cpp
@@ -5,7 +5,7 @@
 #include <evo/netinfo.h>
 
 #include <chainparams.h>
-#include <evo/providertx.h>
+#include <evo/types.h>
 #include <netbase.h>
 #include <span.h>
 #include <util/check.h>
diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index d098690fd1ba..b0bcc3f7f2b5 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -13,38 +13,9 @@
 #include <hash.h>
 #include <script/standard.h>
 #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 ? 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,
-                                                  std::optional<bool> is_basic_override);
-template uint16_t GetMaxFromDeployment<CProUpServTx>(gsl::not_null<const CBlockIndex*> pindexPrev,
-                                                     const ChainstateManager& chainman,
-                                                     std::optional<bool> is_basic_override);
-template uint16_t GetMaxFromDeployment<CProUpRegTx>(gsl::not_null<const CBlockIndex*> pindexPrev,
-                                                    const ChainstateManager& chainman,
-                                                    std::optional<bool> is_basic_override);
-template uint16_t GetMaxFromDeployment<CProUpRevTx>(gsl::not_null<const CBlockIndex*> pindexPrev,
-                                                    const ChainstateManager& chainman,
-                                                    std::optional<bool> is_basic_override);
-} // namespace ProTxVersion
-
 static bool IsValidPayoutScript(const CScript& script)
 {
     return script.IsPayToPublicKeyHash() || script.IsPayToScriptHash();
@@ -60,7 +31,7 @@ bool IsPayoutListTriviallyValid(const MasternodePayoutShares& payouts, const CKe
     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) {
+        if (payout.reward < MasternodePayoutShare::MIN_REWARD || payout.reward > MasternodePayoutShare::MAX_REWARD) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payout-reward");
         }
         total_reward += payout.reward;
@@ -82,7 +53,7 @@ bool IsPayoutListTriviallyValid(const MasternodePayoutShares& payouts, const CKe
         }
     }
 
-    if (total_reward != CMasternodePayoutShare::MAX_REWARD) {
+    if (total_reward != MasternodePayoutShare::MAX_REWARD) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payout-reward-sum");
     }
     return true;
@@ -132,10 +103,9 @@ bool IsNetInfoTriviallyValid(const ProTx& proTx, TxValidationState& state)
     return true;
 }
 
-bool CProRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                                 TxValidationState& state) const
+bool CProRegTx::IsTriviallyValid(TxValidationState& state) const
 {
-    if (nVersion == 0 || nVersion > ProTxVersion::GetMaxFromDeployment<decltype(*this)>(pindexPrev, chainman)) {
+    if (nVersion == 0 || nVersion > ProTxVersion::ExtAddr) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version");
     }
     if (nVersion < ProTxVersion::BasicBLS && nType == MnType::Evo) {
@@ -154,7 +124,7 @@ 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");
     }
-    const auto owner_payouts = GetOwnerPayouts(nVersion, scriptPayout, payouts);
+    const auto owner_payouts = GetOwnerPayouts(*this);
     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");
@@ -183,7 +153,7 @@ std::string CProRegTx::MakeSignString() const
     // We only include the important stuff in the string form...
 
     CTxDestination dest;
-    const std::string strPayout = nVersion >= ProTxVersion::MultiPayout
+    const std::string strPayout = nVersion >= ProTxVersion::ExtAddr
         ? PayoutListToString(payouts)
         : (ExtractDestination(scriptPayout, dest) ? EncodeDestination(dest) : HexStr(scriptPayout));
 
@@ -200,7 +170,7 @@ std::string CProRegTx::MakeSignString() const
 
 std::string CProRegTx::ToString() const
 {
-    const std::string payee = PayoutListToString(GetOwnerPayouts(nVersion, scriptPayout, payouts));
+    const std::string payee = PayoutListToString(GetOwnerPayouts(*this));
 
     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",
@@ -212,10 +182,9 @@ std::string CProRegTx::ToString() const
                           : strprintf(", platformP2PPort=%d, platformHTTPPort=%d", platformP2PPort, platformHTTPPort)));
 }
 
-bool CProUpServTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                                    TxValidationState& state) const
+bool CProUpServTx::IsTriviallyValid(TxValidationState& state) const
 {
-    if (nVersion == 0 || nVersion > ProTxVersion::GetMaxFromDeployment<decltype(*this)>(pindexPrev, chainman)) {
+    if (nVersion == 0 || nVersion > ProTxVersion::ExtAddr) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version");
     }
     if (nVersion < ProTxVersion::BasicBLS && nType == MnType::Evo) {
@@ -257,10 +226,9 @@ std::string CProUpServTx::ToString() const
                           : strprintf(", platformP2PPort=%d, platformHTTPPort=%d", platformP2PPort, platformHTTPPort)));
 }
 
-bool CProUpRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                                   TxValidationState& state) const
+bool CProUpRegTx::IsTriviallyValid(TxValidationState& state) const
 {
-    if (nVersion == 0 || nVersion > ProTxVersion::GetMaxFromDeployment<decltype(*this)>(pindexPrev, chainman)) {
+    if (nVersion == 0 || nVersion > ProTxVersion::ExtAddr) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version");
     }
     if (nMode != 0) {
@@ -273,22 +241,21 @@ 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 (!IsPayoutListTriviallyValid(GetOwnerPayouts(nVersion, scriptPayout, payouts), CKeyID{}, keyIDVoting, state)) return false;
+    if (!IsPayoutListTriviallyValid(GetOwnerPayouts(*this), CKeyID{}, keyIDVoting, state)) return false;
     return true;
 }
 
 std::string CProUpRegTx::ToString() const
 {
-    const std::string payee = PayoutListToString(GetOwnerPayouts(nVersion, scriptPayout, payouts));
+    const std::string payee = PayoutListToString(GetOwnerPayouts(*this));
 
     return strprintf("CProUpRegTx(nVersion=%d, proTxHash=%s, pubKeyOperator=%s, votingAddress=%s, payoutAddress=%s)",
         nVersion, proTxHash.ToString(), pubKeyOperator.ToString(), EncodeDestination(PKHash(keyIDVoting)), payee);
 }
 
-bool CProUpRevTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                                   TxValidationState& state) const
+bool CProUpRevTx::IsTriviallyValid(TxValidationState& state) const
 {
-    if (nVersion == 0 || nVersion > ProTxVersion::GetMaxFromDeployment<decltype(*this)>(pindexPrev, chainman)) {
+    if (nVersion == 0 || nVersion > ProTxVersion::ExtAddr) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version");
     }
 
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index a8c24d34b80b..d27713e74ca7 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -9,6 +9,7 @@
 #include <evo/dmn_types.h>
 #include <evo/netinfo.h>
 #include <evo/specialtx.h>
+#include <evo/types.h>
 #include <primitives/transaction.h>
 #include <util/std23.h>
 
@@ -17,54 +18,15 @@
 #include <netaddress.h>
 #include <pubkey.h>
 
-#include <univalue.h>
 #include <gsl/pointers.h>
+#include <univalue.h>
 
 #include <vector>
 
-class CBlockIndex;
-class ChainstateManager;
 class TxValidationState;
 struct RPCResult;
 
-namespace ProTxVersion {
-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,
-                                        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
-            // avoid accidentally upgrading a legacy BLS node to basic BLS due to v24 activation.
-            return ProTxVersion::ExtAddr;
-        }
-        return ProTxVersion::BasicBLS;
-    }
-    return ProTxVersion::LegacyBLS;
-}
-
-/** Get highest permissible ProTx version based on deployment status
- *  Note: The override is needed because some RPCs need to use deployment status information for everything *except*
- *        the BLS version upgrade since they are specializations for a specific BLS version. This is a one-off.
- *  TODO: Resolve this oddity. Consider deprecating legacy BLS-only RPCs so we can remove them eventually.
- */
-template <typename T>
-[[nodiscard]] uint16_t GetMaxFromDeployment(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                                            std::optional<bool> is_basic_override = std::nullopt);
-} // namespace ProTxVersion
-
-class CMasternodePayoutShare
+class MasternodePayoutShare
 {
 public:
     static constexpr uint16_t MIN_REWARD = 100;
@@ -73,30 +35,21 @@ class CMasternodePayoutShare
     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)
+    SERIALIZE_METHODS(MasternodePayoutShare, 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); }
+    bool operator==(const MasternodePayoutShare& b) const = default;
+    bool operator!=(const MasternodePayoutShare& b) const = default;
 };
 
-using MasternodePayoutShares = std::vector<CMasternodePayoutShare>;
+using MasternodePayoutShares = std::vector<MasternodePayoutShare>;
 
 [[nodiscard]] MasternodePayoutShares LegacyPayoutAsList(const CScript& script_payout);
-[[nodiscard]] MasternodePayoutShares GetOwnerPayouts(uint16_t nVersion, const CScript& script_payout,
-                                                     const MasternodePayoutShares& payouts);
+template<class T>
+[[nodiscard]] MasternodePayoutShares GetOwnerPayouts(const T& protx);
+
 [[nodiscard]] bool IsPayoutListTriviallyValid(const MasternodePayoutShares& payouts, const CKeyID& keyIDOwner,
                                               const CKeyID& keyIDVoting, TxValidationState& state);
 [[nodiscard]] bool IsPayoutListKeySafe(const MasternodePayoutShares& payouts, const CTxDestination& collateral_dest,
@@ -133,7 +86,7 @@ class CProRegTx
                 obj.nVersion
         );
         if (obj.nVersion == 0 ||
-            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true, /*is_multi_payout=*/true)) {
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
             // unknown version, bail out early
             return;
         }
@@ -149,7 +102,7 @@ class CProRegTx
                 obj.keyIDVoting,
                 obj.nOperatorReward
         );
-        if (obj.nVersion >= ProTxVersion::MultiPayout) {
+        if (obj.nVersion >= ProTxVersion::ExtAddr) {
             uint8_t payouts_count{0};
             SER_WRITE(obj, payouts_count = static_cast<uint8_t>(obj.payouts.size()));
             READWRITE(payouts_count);
@@ -186,8 +139,11 @@ class CProRegTx
     [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
     [[nodiscard]] UniValue ToJson() const;
 
-    bool IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                          TxValidationState& state) const;
+    /**
+     * Note: this check validates only some trivial consensus rules
+     * Use `CheckProRegTx` or GetValidatedPayload<T> helper for full validation
+     */
+    bool IsTriviallyValid(TxValidationState& state) const;
 };
 
 class CProUpServTx
@@ -212,7 +168,7 @@ class CProUpServTx
                 obj.nVersion
         );
         if (obj.nVersion == 0 ||
-            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true, /*is_multi_payout=*/true)) {
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
             // unknown version, bail out early
             return;
         }
@@ -248,8 +204,11 @@ class CProUpServTx
     [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
     [[nodiscard]] UniValue ToJson() const;
 
-    bool IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                          TxValidationState& state) const;
+    /**
+     * Note: this check validates only some trivial consensus rules
+     * Use `CheckProUpServTx` or GetValidatedPayload<T> helper for full validation
+     */
+    bool IsTriviallyValid(TxValidationState& state) const;
 };
 
 class CProUpRegTx
@@ -273,7 +232,7 @@ class CProUpRegTx
                 obj.nVersion
         );
         if (obj.nVersion == 0 ||
-            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true, /*is_multi_payout=*/true)) {
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
             // unknown version, bail out early
             return;
         }
@@ -283,7 +242,7 @@ class CProUpRegTx
                 CBLSLazyPublicKeyVersionWrapper(const_cast<CBLSLazyPublicKey&>(obj.pubKeyOperator), (obj.nVersion == ProTxVersion::LegacyBLS)),
                 obj.keyIDVoting
         );
-        if (obj.nVersion >= ProTxVersion::MultiPayout) {
+        if (obj.nVersion >= ProTxVersion::ExtAddr) {
             uint8_t payouts_count{0};
             SER_WRITE(obj, payouts_count = static_cast<uint8_t>(obj.payouts.size()));
             READWRITE(payouts_count);
@@ -309,8 +268,11 @@ class CProUpRegTx
     [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
     [[nodiscard]] UniValue ToJson() const;
 
-    bool IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                          TxValidationState& state) const;
+    /**
+     * Note: this check validates only some trivial consensus rules
+     * Use `CheckProUpRegTx` or GetValidatedPayload<T> helper for full validation
+     */
+    bool IsTriviallyValid(TxValidationState& state) const;
 };
 
 class CProUpRevTx
@@ -339,7 +301,7 @@ class CProUpRevTx
                 obj.nVersion
         );
         if (obj.nVersion == 0 ||
-            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true, /*is_multi_payout=*/true)) {
+            obj.nVersion > ProTxVersion::GetMax(/*is_basic_scheme_active=*/true, /*is_extended_addr=*/true)) {
             // unknown version, bail out early
             return;
         }
@@ -360,8 +322,11 @@ class CProUpRevTx
     [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
     [[nodiscard]] UniValue ToJson() const;
 
-    bool IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
-                          TxValidationState& state) const;
+    /**
+     * Note: this check validates only some trivial consensus rules
+     * Use `CheckProUpRevTx` or GetValidatedPayload<T> helper for full validation
+     */
+    bool IsTriviallyValid(TxValidationState& state) const;
 };
 
 template <typename ProTx>
diff --git a/src/evo/providertx_util.cpp b/src/evo/providertx_util.cpp
index 0d963b4fb6d6..478799ba1da7 100644
--- a/src/evo/providertx_util.cpp
+++ b/src/evo/providertx_util.cpp
@@ -3,6 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <evo/providertx.h>
+#include <evo/dmnstate.h>
 
 #include <key_io.h>
 #include <script/standard.h>
@@ -17,15 +18,19 @@
 
 MasternodePayoutShares LegacyPayoutAsList(const CScript& script_payout)
 {
-    return {{script_payout, CMasternodePayoutShare::MAX_REWARD}};
+    return {{script_payout, MasternodePayoutShare::MAX_REWARD}};
 }
 
-MasternodePayoutShares GetOwnerPayouts(const uint16_t nVersion, const CScript& script_payout,
-                                       const MasternodePayoutShares& payouts)
+template<class T>
+MasternodePayoutShares GetOwnerPayouts(const T& protx)
 {
-    return nVersion >= ProTxVersion::MultiPayout ? payouts : LegacyPayoutAsList(script_payout);
+    return protx.nVersion >= ProTxVersion::ExtAddr ? protx.payouts : LegacyPayoutAsList(protx.scriptPayout);
 }
 
+template MasternodePayoutShares GetOwnerPayouts(const CProRegTx& protx);
+template MasternodePayoutShares GetOwnerPayouts(const CProUpRegTx& protx);
+template MasternodePayoutShares GetOwnerPayouts(const CDeterministicMNState& protx);
+
 std::string PayoutListToString(const MasternodePayoutShares& payouts)
 {
     std::string ret;
diff --git a/src/evo/specialtx_filter.cpp b/src/evo/specialtx_filter.cpp
index cd11be7708f6..ac5c0adcce70 100644
--- a/src/evo/specialtx_filter.cpp
+++ b/src/evo/specialtx_filter.cpp
@@ -73,7 +73,7 @@ void ExtractSpecialTxFilterElements(const CTransaction& tx, const std::function<
             AddHashElement(opt_proTx->keyIDVoting, addElement);
 
             // Add owner payout scripts
-            for (const auto& payout : GetOwnerPayouts(opt_proTx->nVersion, opt_proTx->scriptPayout, opt_proTx->payouts)) {
+            for (const auto& payout : GetOwnerPayouts(*opt_proTx)) {
                 AddScriptElement(payout.scriptPayout, addElement);
             }
         }
@@ -98,7 +98,7 @@ void ExtractSpecialTxFilterElements(const CTransaction& tx, const std::function<
             AddHashElement(opt_proTx->keyIDVoting, addElement);
 
             // Add owner payout scripts
-            for (const auto& payout : GetOwnerPayouts(opt_proTx->nVersion, opt_proTx->scriptPayout, opt_proTx->payouts)) {
+            for (const auto& payout : GetOwnerPayouts(*opt_proTx)) {
                 AddScriptElement(payout.scriptPayout, addElement);
             }
         }
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index bc68f76664f1..e973dd31a951 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -45,6 +45,12 @@ static bool SetStateVersion(CDeterministicMNState& state_mn, uint16_t nVersion,
                             BlockValidationState& state)
 {
     const bool needs_extended = nVersion >= ProTxVersion::ExtAddr;
+    // Before the early-return: ProUpServ pre-sets nVersion, so migrate scriptPayout into the ExtAddr
+    // payout list here or it would be skipped.
+    if (needs_extended && state_mn.payouts.empty() && !state_mn.scriptPayout.empty()) {
+        state_mn.payouts = LegacyPayoutAsList(state_mn.scriptPayout);
+        state_mn.scriptPayout.clear();
+    }
     if (state_mn.nVersion == nVersion && state_mn.netInfo->CanStorePlatform() == needs_extended) {
         return true;
     }
@@ -488,8 +494,8 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
             if (operator_changed) {
                 newState->pubKeyOperator.SetLegacy(target_version == ProTxVersion::LegacyBLS);
             }
-            if (target_version >= ProTxVersion::MultiPayout) {
-                newState->payouts = opt_proTx->nVersion >= ProTxVersion::MultiPayout
+            if (target_version >= ProTxVersion::ExtAddr) {
+                newState->payouts = opt_proTx->nVersion >= ProTxVersion::ExtAddr
                     ? opt_proTx->payouts
                     : LegacyPayoutAsList(opt_proTx->scriptPayout);
                 newState->scriptPayout.clear();
@@ -516,8 +522,15 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
             }
             auto newState = std::make_shared<CDeterministicMNState>(*dmn->pdmnState);
             const uint16_t old_version{static_cast<uint16_t>(newState->nVersion)};
+            // ResetOperatorFields() drops nVersion back to LegacyBLS. Post-v24 the state version must be
+            // preserved (never silently downgraded), so pick the target the same max-based way the registrar
+            // path does and restore it below. Pre-v24 keep the historical reset-to-legacy behaviour.
+            uint16_t target_version{ProTxVersion::LegacyBLS};
+            if (is_v24_deployed) {
+                target_version = std::max<uint16_t>(old_version, opt_proTx->nVersion);
+            }
             newState->ResetOperatorFields();
-            if (old_version >= ProTxVersion::MultiPayout && !SetStateVersion(*newState, old_version, dmn->nType, state)) {
+            if (target_version >= ProTxVersion::BasicBLS && !SetStateVersion(*newState, target_version, dmn->nType, state)) {
                 return false;
             }
             newState->BanIfNotBanned(nHeight);
@@ -963,8 +976,8 @@ static bool CheckHashSig(const ProTx& proTx, const CBLSPublicKey& pubKey, TxVali
 }
 
 template <typename ProTx>
-static std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
-                                                const ChainstateManager& chainman, TxValidationState& state)
+std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
+                                         const ChainstateManager& chainman, TxValidationState& state)
 {
     if (tx.nType != ProTx::SPECIALTX_TYPE) {
         state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-type");
@@ -976,7 +989,11 @@ static std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not
         state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-payload");
         return std::nullopt;
     }
-    if (!opt_ptx->IsTriviallyValid(pindexPrev, chainman, state)) {
+    if (opt_ptx->nVersion > DeploymentToProtxVersion(pindexPrev, chainman)) {
+        state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version");
+        return std::nullopt;
+    }
+    if (!opt_ptx->IsTriviallyValid(state)) {
         // pass the state returned by the function above
         return std::nullopt;
     }
@@ -986,15 +1003,13 @@ static std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not
 /**
  * Validates potential changes to masternode state version by ProTx transaction version
  * @param[in]  pindexPrev    Previous block index to validate DEPLOYMENT_V24 activation
- * @param[in]  tx_type       Special transaction type
  * @param[in]  state_version Current masternode state version
  * @param[in]  tx_version    Proposed transaction version
  * @param[out] state         This may be set to an Error state if any error occurred processing them
  * @returns                  true if version change is valid or DEPLOYMENT_V24 is not active
  */
-static bool IsVersionChangeValid(gsl::not_null<const CBlockIndex*> pindexPrev, const uint16_t tx_type,
-                                 const uint16_t state_version, const uint16_t tx_version,
-                                 const ChainstateManager& chainman, TxValidationState& state)
+static bool IsVersionChangeValid(gsl::not_null<const CBlockIndex*> pindexPrev, const uint16_t state_version,
+                                 const uint16_t tx_version, const ChainstateManager& chainman, TxValidationState& state)
 {
     if (!DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)) {
         // New restrictions only apply after v24 deployment
@@ -1006,19 +1021,6 @@ static bool IsVersionChangeValid(gsl::not_null<const CBlockIndex*> pindexPrev, c
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-downgrade");
     }
 
-    if (state_version == ProTxVersion::LegacyBLS && tx_version > ProTxVersion::BasicBLS) {
-        // Nodes using the legacy scheme must first upgrade to the basic scheme before upgrading further
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-upgrade");
-    }
-
-    if (tx_type != TRANSACTION_PROVIDER_UPDATE_SERVICE && tx_version == ProTxVersion::ExtAddr) {
-        // 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;
 }
 
@@ -1093,9 +1095,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 (!IsPayoutListKeySafe(GetOwnerPayouts(opt_ptx->nVersion, opt_ptx->scriptPayout, opt_ptx->payouts),
+    if (!IsPayoutListKeySafe(GetOwnerPayouts(*opt_ptx),
                              collateralTxDest, opt_ptx->keyIDOwner, opt_ptx->keyIDVoting,
-                             opt_ptx->nVersion >= ProTxVersion::MultiPayout, state)) return false;
+                             opt_ptx->nVersion >= ProTxVersion::ExtAddr, state)) return false;
 
     if (pindexPrev) {
         auto mnList = dmnman.GetListForBlock(pindexPrev);
@@ -1183,7 +1185,7 @@ bool CheckProUpServTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*>
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-hash");
     }
 
-    if (!IsVersionChangeValid(pindexPrev, tx.nType, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
+    if (!IsVersionChangeValid(pindexPrev, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
         // pass the state returned by the function above
         return false;
     }
@@ -1252,12 +1254,12 @@ bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-hash");
     }
 
-    if (!IsVersionChangeValid(pindexPrev, tx.nType, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
+    if (!IsVersionChangeValid(pindexPrev, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
         // pass the state returned by the function above
         return false;
     }
 
-    const auto owner_payouts = GetOwnerPayouts(opt_ptx->nVersion, opt_ptx->scriptPayout, opt_ptx->payouts);
+    const auto owner_payouts = GetOwnerPayouts(*opt_ptx);
     if (!IsPayoutListTriviallyValid(owner_payouts, dmn->pdmnState->keyIDOwner, opt_ptx->keyIDVoting, state)) return false;
 
     Coin coin;
@@ -1272,7 +1274,7 @@ bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-collateral-dest");
     }
     const bool check_payout_collateral_reuse{
-        std::max<uint16_t>(dmn->pdmnState->nVersion, opt_ptx->nVersion) >= ProTxVersion::MultiPayout};
+        std::max<uint16_t>(dmn->pdmnState->nVersion, opt_ptx->nVersion) >= ProTxVersion::ExtAddr};
     if (!IsPayoutListKeySafe(owner_payouts, collateralTxDest, dmn->pdmnState->keyIDOwner, opt_ptx->keyIDVoting,
                              check_payout_collateral_reuse, state)) return false;
 
@@ -1316,7 +1318,7 @@ bool CheckProUpRevTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> p
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-hash");
     }
 
-    if (!IsVersionChangeValid(pindexPrev, tx.nType, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
+    if (!IsVersionChangeValid(pindexPrev, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
         // pass the state returned by the function above
         return false;
     }
diff --git a/src/evo/specialtxman.h b/src/evo/specialtxman.h
index 013fbfa5f1b7..b4e0d7168538 100644
--- a/src/evo/specialtxman.h
+++ b/src/evo/specialtxman.h
@@ -93,6 +93,14 @@ class CSpecialTxProcessor
                                      BlockValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 };
 
+/**
+ * This helper does some trivial validations that doesn't depends on collateral and
+ * masternode list. Use CheckPro*Tx for the full validation of transaction,
+ * including bls signatures, list of masternodes and collateral
+ */
+template <typename ProTx>
+std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
+                                         const ChainstateManager& chainman, TxValidationState& state);
 
 /** Validates the bestCLSignature / bestCLHeightDiff fields embedded in a CbTx payload. */
 bool CheckCbTxBestChainlock(const CCbTx& cbTx, const CBlockIndex* pindex, const Consensus::Params& consensus_params,
diff --git a/src/evo/types.h b/src/evo/types.h
index 1bc7a47715bf..501110607efe 100644
--- a/src/evo/types.h
+++ b/src/evo/types.h
@@ -5,10 +5,35 @@
 #ifndef BITCOIN_EVO_TYPES_H
 #define BITCOIN_EVO_TYPES_H
 
+#include <cstdint>
 #include <memory>
 
 class CDeterministicMN;
 
 using CDeterministicMNCPtr = std::shared_ptr<const CDeterministicMN>;
 
+namespace ProTxVersion {
+enum : uint16_t {
+    LegacyBLS = 1,
+    BasicBLS = 2,
+    ExtAddr = 3,
+};
+
+/** 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)
+{
+    if (is_basic_scheme_active) {
+        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
+            // avoid accidentally upgrading a legacy BLS node to basic BLS due to v24 activation.
+            return ProTxVersion::ExtAddr;
+        }
+        return ProTxVersion::BasicBLS;
+    }
+    return ProTxVersion::LegacyBLS;
+}
+
+} // namespace ProTxVersion
+
 #endif // BITCOIN_EVO_TYPES_H
diff --git a/src/masternode/payments.cpp b/src/masternode/payments.cpp
index f3f090e80942..0adde44f4d66 100644
--- a/src/masternode/payments.cpp
+++ b/src/masternode/payments.cpp
@@ -138,13 +138,12 @@ CAmount GetMasternodePayment(int nHeight, CAmount blockValue, const Consensus::P
         masternodeReward -= operatorReward;
     }
 
-    const auto owner_payouts = GetOwnerPayouts(dmnPayee->pdmnState->nVersion, dmnPayee->pdmnState->scriptPayout,
-                                               dmnPayee->pdmnState->payouts);
+    const auto owner_payouts = GetOwnerPayouts(*dmnPayee->pdmnState);
     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;
+                                           : (masternodeReward * owner_payouts[i].reward) / MasternodePayoutShare::MAX_REWARD;
         paid_owner_reward += payout_amount;
         if (payout_amount > 0) {
             voutMasternodePaymentsRet.emplace_back(payout_amount, owner_payouts[i].scriptPayout);
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 385ee4aefa78..13e3a7e96533 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -101,11 +101,10 @@ using interfaces::WalletLoader;
 
 namespace node {
 namespace {
-std::vector<CScript> GetOwnerPayoutScripts(const CDeterministicMN& dmn)
+std::vector<CScript> GetOwnerPayoutScripts(const CDeterministicMNState& state)
 {
     std::vector<CScript> ret;
-    for (const auto& payout : GetOwnerPayouts(dmn.pdmnState->nVersion, dmn.pdmnState->scriptPayout,
-                                              dmn.pdmnState->payouts)) {
+    for (const auto& payout : GetOwnerPayouts(state)) {
         ret.emplace_back(payout.scriptPayout);
     }
     return ret;
@@ -122,8 +121,8 @@ class MnEntryImpl : public MnEntry
     MnEntryImpl(const CDeterministicMNCPtr& dmn) :
         MnEntry{dmn},
         m_dmn{Assert(dmn)},
-        m_script_payouts{GetOwnerPayoutScripts(*m_dmn)},
-        m_script_payout{m_script_payouts.front()}
+        m_script_payouts{GetOwnerPayoutScripts(*m_dmn->pdmnState)},
+        m_script_payout{m_script_payouts.empty() ? CScript() : m_script_payouts.front()}
     {
     }
     ~MnEntryImpl() = default;
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 59ff1c0e7cc4..19add2fe9e66 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -152,8 +152,8 @@ static RPCArg GetRpcArg(const std::string& strParamName)
         },
         {"payoutAddress_register",
             {"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.",
+                "The Dash address to use for masternode reward payments, or after v24 activation, "
+                "an array of payout shares. Not compatible with legacy bls operator key.",
                 {
                     {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
                         {
@@ -165,8 +165,8 @@ static RPCArg GetRpcArg(const std::string& strParamName)
         },
         {"payoutAddress_update",
             {"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"
+                "The Dash address to use for masternode reward payments, or after v24 activation, "
+                "an array of payout shares. Not compatible with legacy bls operator key.\n"
                 "If set to an empty string, the currently active payout address is reused.",
                 {
                     {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
@@ -325,7 +325,7 @@ static MasternodePayoutShares ParsePayouts(const UniValue& value, const std::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);
+        payouts.emplace_back(GetScriptForDestination(first_dest), MasternodePayoutShare::MAX_REWARD);
     }
     return payouts;
 }
@@ -788,8 +788,8 @@ static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
 
     CProRegTx ptx;
     ptx.nType = mnType;
-    ptx.nVersion = ProTxVersion::GetMaxFromDeployment<CProRegTx>(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()),
-                                                                 chainman, /*is_basic_override=*/!use_legacy);
+    ptx.nVersion = DeploymentToProtxVersion(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()), chainman,
+                                            /*is_basic_override=*/!use_legacy);
     ptx.netInfo = NetInfoInterface::MakeNetInfo(ptx.nVersion);
 
     if (action == ProTxRegisterAction::Fund) {
@@ -837,8 +837,8 @@ static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
     ptx.nOperatorReward = operatorReward;
 
     CTxDestination payoutDest;
-    if (request.params[paramIdx + 5].isArray() && ptx.nVersion < ProTxVersion::MultiPayout) {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, "payouts array requires provider transaction version 4");
+    if (request.params[paramIdx + 5].isArray() && ptx.nVersion < ProTxVersion::ExtAddr) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "payouts array requires provider transaction version 3");
     }
     ptx.payouts = ParsePayouts(request.params[paramIdx + 5], "payouts", payoutDest);
 
@@ -1103,15 +1103,7 @@ static UniValue protx_update_service_common_wrapper(const JSONRPCRequest& reques
         throw std::runtime_error(strprintf("masternode with proTxHash %s is not a %s", ptx.proTxHash.ToString(), GetMnType(mnType).description));
     }
 
-    ptx.nVersion = ProTxVersion::GetMaxFromDeployment<CProUpServTx>(WITH_LOCK(::cs_main,
-                                                                              return chainman.ActiveChain().Tip()),
-                                                                    chainman);
-
-    // Legacy masternodes must upgrade to BasicBLS before using higher versions.
-    // Clamp to BasicBLS to avoid "bad-protx-version-upgrade" validation failure.
-    if (dmn->pdmnState->nVersion == ProTxVersion::LegacyBLS && ptx.nVersion > ProTxVersion::BasicBLS) {
-        ptx.nVersion = ProTxVersion::BasicBLS;
-    }
+    ptx.nVersion = DeploymentToProtxVersion(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()), chainman);
 
     ptx.netInfo = NetInfoInterface::MakeNetInfo(ptx.nVersion);
 
@@ -1167,7 +1159,7 @@ static UniValue protx_update_service_common_wrapper(const JSONRPCRequest& reques
             ExtractDestination(ptx.scriptOperatorPayout, feeSource);
         } else {
             // use payout address as default source for fees
-            const auto owner_payouts = GetOwnerPayouts(dmn->pdmnState->nVersion, dmn->pdmnState->scriptPayout, dmn->pdmnState->payouts);
+            const auto owner_payouts = GetOwnerPayouts(*dmn->pdmnState);
             ExtractDestination(owner_payouts.front().scriptPayout, feeSource);
         }
     }
@@ -1233,21 +1225,18 @@ static RPCHelpMan protx_update_registrar_wrapper(const bool specific_legacy_bls_
     EnsureWalletIsUnlocked(*wallet);
 
     CProUpRegTx ptx;
-    ptx.nVersion = ProTxVersion::GetMaxFromDeployment<CProUpRegTx>(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()),
-                                                                   chainman, /*is_basic_override=*/!use_legacy);
+    ptx.nVersion = DeploymentToProtxVersion(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()), chainman,
+                                            /*is_basic_override=*/!use_legacy);
 
     ptx.proTxHash = ParseHashV(request.params[0], "proTxHash");
     auto dmn = dmnman.GetListAtChainTip().GetMN(ptx.proTxHash);
     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);
+    ptx.payouts = GetOwnerPayouts(*dmn->pdmnState);
 
     if (!request.params[1].get_str().empty()) {
         // new pubkey
@@ -1266,8 +1255,8 @@ static RPCHelpMan protx_update_registrar_wrapper(const bool specific_legacy_bls_
     CTxDestination payoutDest;
     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");
+        if (ptx.nVersion < ProTxVersion::ExtAddr) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "payouts array requires provider transaction version 3");
         }
         ptx.payouts = ParsePayouts(request.params[3], "payouts", payoutDest);
         ptx.scriptPayout = ptx.payouts.front().scriptPayout;
@@ -1367,14 +1356,7 @@ static RPCHelpMan protx_revoke()
         throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("masternode %s not found", ptx.proTxHash.ToString()));
     }
 
-    ptx.nVersion = ProTxVersion::GetMaxFromDeployment<CProUpRevTx>(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()),
-                                                                   chainman);
-
-    // Legacy masternodes must upgrade to BasicBLS before using higher versions.
-    // Clamp to BasicBLS to avoid "bad-protx-version-upgrade" validation failure.
-    if (dmn->pdmnState->nVersion == ProTxVersion::LegacyBLS && ptx.nVersion > ProTxVersion::BasicBLS) {
-        ptx.nVersion = ProTxVersion::BasicBLS;
-    }
+    ptx.nVersion = DeploymentToProtxVersion(WITH_LOCK(::cs_main, return chainman.ActiveChain().Tip()), chainman);
 
     CBLSSecretKey keyOperator = ParseBLSSecretKey(request.params[1].get_str(), "operatorKey");
 
@@ -1407,7 +1389,7 @@ static RPCHelpMan protx_revoke()
     } else {
         // Using funds from previousely specified masternode payout address
         CTxDestination txDest;
-        const auto owner_payouts = GetOwnerPayouts(dmn->pdmnState->nVersion, dmn->pdmnState->scriptPayout, dmn->pdmnState->payouts);
+        const auto owner_payouts = GetOwnerPayouts(*dmn->pdmnState);
         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");
         }
@@ -1439,7 +1421,7 @@ static bool CheckWalletOwnsScript(const CWallet* const pwallet, const CScript& s
 
 static bool CheckWalletOwnsAnyPayout(const CWallet* const pwallet, const CDeterministicMNState& state)
 {
-    for (const auto& payout : GetOwnerPayouts(state.nVersion, state.scriptPayout, state.payouts)) {
+    for (const auto& payout : GetOwnerPayouts(state)) {
         if (CheckWalletOwnsScript(pwallet, payout.scriptPayout)) return true;
     }
     return false;
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index 2eb8940767b1..9417fee601b8 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -229,8 +229,7 @@ static std::string GetRequiredPaymentsString(governance::SuperblockManager& supe
     std::string strPayments = "Unknown";
     if (payee) {
         strPayments.clear();
-        for (const auto& payout : GetOwnerPayouts(payee->pdmnState->nVersion, payee->pdmnState->scriptPayout,
-                                                  payee->pdmnState->payouts)) {
+        for (const auto& payout : GetOwnerPayouts(*payee->pdmnState)) {
             CTxDestination dest;
             if (!ExtractDestination(payout.scriptPayout, dest)) {
                 NONFATAL_UNREACHABLE();
@@ -269,7 +268,7 @@ static std::string GetRequiredPaymentsString(governance::SuperblockManager& supe
 static std::string GetOwnerPayoutsString(const CDeterministicMNState& state)
 {
     std::string str_payees;
-    for (const auto& payout : GetOwnerPayouts(state.nVersion, state.scriptPayout, state.payouts)) {
+    for (const auto& payout : GetOwnerPayouts(state)) {
         CTxDestination dest;
         if (!ExtractDestination(payout.scriptPayout, dest)) {
             NONFATAL_UNREACHABLE();
diff --git a/src/test/data/trivially_invalid.json b/src/test/data/trivially_invalid.json
index cfc789cbee37..88489086c809 100644
--- a/src/test/data/trivially_invalid.json
+++ b/src/test/data/trivially_invalid.json
@@ -85,7 +85,7 @@
     "proupregtx",
     "legacy",
     "03000300010000000000000000000000000000000000000000000000000000000000000000ffffffff016affffffff0100f2052a01000000016a00000000e40000bfd280d22a21574ea9f568f7a729b370f4051b89eab6df3d0d74b65fde1bdb7900000a6a7fb814db71eb6ef12341749d81b5fd326eb4b9445a3be65668da9856910b378ec6427fe18fc81c39499e7c7060647618f8ec94404051e4a7ab68f1b017fd9e7f94761976a914c18e0b18e0d992e7471d8a4d4da428e8e191328788ac959ca83b61eeb3f5543973253da6da8e9ac23f9e7844453ac5543b51d0177799416666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666",
-    "gettxpayload-fail",
+    "bad-protx-payload",
     "Transaction with version set to null"
 ],
 [
diff --git a/src/test/evo_deterministicmns_tests.cpp b/src/test/evo_deterministicmns_tests.cpp
index 3af64daa6347..24d1f10e18ac 100644
--- a/src/test/evo_deterministicmns_tests.cpp
+++ b/src/test/evo_deterministicmns_tests.cpp
@@ -516,7 +516,7 @@ void FuncProUpRegTxVersionHandlingBeforeV24(TestChainSetup& setup)
     BOOST_CHECK(dmn->pdmnState->pubKeyOperator.Get() == operator_key_legacy.GetPublicKey());
 };
 
-void FuncProUpRegTxV4OnLegacyRejected(TestChainSetup& setup)
+void FuncProUpRegTxV3OnLegacyValid(TestChainSetup& setup)
 {
     auto& chainman = *Assert(setup.m_node.chainman.get());
     auto& dmnman = *Assert(setup.m_node.dmnman);
@@ -548,11 +548,11 @@ void FuncProUpRegTxV4OnLegacyRejected(TestChainSetup& setup)
     BOOST_REQUIRE_EQUAL(dmnman.GetListAtChainTip().GetMN(proTxHash)->pdmnState->nVersion, ProTxVersion::LegacyBLS);
 
     CProUpRegTx proTx;
-    proTx.nVersion = ProTxVersion::MultiPayout;
+    proTx.nVersion = ProTxVersion::ExtAddr;
     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}};
+    proTx.payouts = {{GenerateRandomAddress(), MasternodePayoutShare::MAX_REWARD}};
 
     CMutableTransaction tx;
     tx.nVersion = 3;
@@ -567,13 +567,13 @@ void FuncProUpRegTxV4OnLegacyRejected(TestChainSetup& setup)
     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(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");
+    BOOST_CHECK(val_state.IsValid());
 };
 
-void FuncProUpRegTxV2CannotBypassV4PayoutCollateralReuse(TestChainSetup& setup)
+void FuncProUpRegTxV2CannotBypassV3PayoutCollateralReuse(TestChainSetup& setup)
 {
     auto& chainman = *Assert(setup.m_node.chainman.get());
     auto& dmnman = *Assert(setup.m_node.dmnman);
@@ -606,13 +606,13 @@ void FuncProUpRegTxV2CannotBypassV4PayoutCollateralReuse(TestChainSetup& setup)
     dmnman.UpdatedBlockTip(chainman.ActiveChain().Tip());
 
     CProRegTx pro_reg;
-    pro_reg.nVersion = ProTxVersion::MultiPayout;
+    pro_reg.nVersion = ProTxVersion::ExtAddr;
     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}};
+    pro_reg.payouts = {{script_payout, MasternodePayoutShare::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);
@@ -635,7 +635,7 @@ void FuncProUpRegTxV2CannotBypassV4PayoutCollateralReuse(TestChainSetup& setup)
 
     auto dmn = dmnman.GetListAtChainTip().GetMN(proTxHash);
     BOOST_REQUIRE(dmn);
-    BOOST_CHECK_EQUAL(dmn->pdmnState->nVersion, ProTxVersion::MultiPayout);
+    BOOST_CHECK_EQUAL(dmn->pdmnState->nVersion, ProTxVersion::ExtAddr);
     BOOST_CHECK_EQUAL(dmn->pdmnState->payouts.size(), 1U);
     BOOST_CHECK(dmn->pdmnState->payouts.front().scriptPayout == script_payout);
 
@@ -1256,16 +1256,16 @@ BOOST_AUTO_TEST_CASE(proupreg_version_handling_before_v24)
     FuncProUpRegTxVersionHandlingBeforeV24(setup);
 }
 
-BOOST_AUTO_TEST_CASE(proupreg_v4_on_legacy_rejected)
+BOOST_AUTO_TEST_CASE(proupreg_v3_on_legacy_rejected)
 {
     TestChainV24SignalBeforeV19Setup setup;
-    FuncProUpRegTxV4OnLegacyRejected(setup);
+    FuncProUpRegTxV3OnLegacyValid(setup);
 }
 
-BOOST_AUTO_TEST_CASE(proupreg_v2_cannot_bypass_v4_payout_collateral_reuse)
+BOOST_AUTO_TEST_CASE(proupreg_v2_cannot_bypass_v3_payout_collateral_reuse)
 {
     TestChainV24SignalBeforeV19Setup setup;
-    FuncProUpRegTxV2CannotBypassV4PayoutCollateralReuse(setup);
+    FuncProUpRegTxV2CannotBypassV3PayoutCollateralReuse(setup);
 }
 
 BOOST_AUTO_TEST_CASE(dip3_protx_legacy)
diff --git a/src/test/evo_trivialvalidation.cpp b/src/test/evo_trivialvalidation.cpp
index 1e47c3f9dfa2..2185e0eca3fc 100644
--- a/src/test/evo_trivialvalidation.cpp
+++ b/src/test/evo_trivialvalidation.cpp
@@ -11,6 +11,7 @@
 #include <chainparams.h>
 #include <deploymentstatus.h>
 #include <evo/providertx.h>
+#include <evo/specialtxman.h>
 #include <key.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
@@ -32,22 +33,20 @@ template <class T>
 void TestTxHelper(const CMutableTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
                   const std::optional<std::string>& expected_error, const ChainstateManager& chainman)
 {
-    const bool payload_to_fail = expected_error.has_value() && expected_error.value() == "gettxpayload-fail";
-    const auto opt_payload = GetTxPayload<T>(tx, false);
-    BOOST_CHECK_EQUAL(opt_payload.has_value(), !payload_to_fail);
+    TxValidationState dummy_state;
+    auto opt_payload = GetValidatedPayload<T>(CTransaction{tx}, pindexPrev, chainman, dummy_state);
 
-    // No need to check anything else if GetTxPayload() expected to fail
-    if (payload_to_fail) return;
+    BOOST_CHECK_EQUAL(opt_payload.has_value(), !expected_error.has_value());
 
-    TxValidationState dummy_state;
-    BOOST_CHECK_EQUAL(opt_payload->IsTriviallyValid(pindexPrev, chainman, dummy_state), !expected_error.has_value());
     if (expected_error.has_value()) {
         BOOST_CHECK_EQUAL(dummy_state.GetRejectReason(), expected_error.value());
     }
 }
 
-void trivialvalidation_runner(const ChainstateManager& chainman, const std::string& json)
+void trivialvalidation_runner(ChainstateManager& chainman, const std::string& json)
 {
+    LOCK(::cs_main);
+
     const UniValue vectors = read_json(json);
 
     for (size_t idx = 1; idx < vectors.size(); idx++) {
@@ -75,7 +74,7 @@ void trivialvalidation_runner(const ChainstateManager& chainman, const std::stri
             BOOST_CHECK_EQUAL(tx.nVersion, 3);
             BOOST_CHECK_EQUAL(tx.GetHash(), txHash);
             // Deserialization based on transaction nType
-            TxValidationState dummy_state;
+
             switch (tx.nType) {
             case TRANSACTION_PROVIDER_REGISTER: {
                 BOOST_CHECK_EQUAL(txType, "proregtx");
@@ -174,7 +173,7 @@ BOOST_AUTO_TEST_CASE(multipayout_list_validation)
     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, MasternodePayoutShare::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");
diff --git a/src/validation.cpp b/src/validation.cpp
index a57796595dc6..d5b5cbfd33b0 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -5929,3 +5929,12 @@ bool IsBIP30Unspendable(const CBlockIndex& block_index)
     return (block_index.nHeight==91722 && block_index.GetBlockHash() == uint256S("0x00000000000271a2dc26e7667f8419f2e15416dc6955e5a6c6cdf3f2574dd08e")) ||
            (block_index.nHeight==91812 && block_index.GetBlockHash() == uint256S("0x00000000000af0aed4792b1acee3d966af36cf5def14935db8de83d6f9306f2f"));
 }
+
+[[nodiscard]] uint16_t DeploymentToProtxVersion(gsl::not_null<const CBlockIndex*> pindexPrev,
+                                                const ChainstateManager& chainman, std::optional<bool> is_basic_override)
+{
+    return ProTxVersion::GetMax(
+        is_basic_override ? *is_basic_override
+                          : DeploymentActiveAfter(pindexPrev, chainman.GetConsensus(), Consensus::DEPLOYMENT_V19),
+        DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24));
+}
diff --git a/src/validation.h b/src/validation.h
index 627c241e9f6a..5ff18850d658 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -1108,6 +1108,14 @@ bool DeploymentEnabled(const ChainstateManager& chainman, DEP dep)
     return DeploymentEnabled(chainman.GetConsensus(), dep);
 }
 
+/** Get highest permissible ProTx version based on deployment status
+ *  Note: The override is needed because some RPCs need to use deployment status information for everything *except*
+ *        the BLS version upgrade since they are specializations for a specific BLS version. This is a one-off.
+ *  TODO: Resolve this oddity. Consider deprecating legacy BLS-only RPCs so we can remove them eventually.
+ */
+[[nodiscard]] uint16_t DeploymentToProtxVersion(gsl::not_null<const CBlockIndex*> pindexPrev, const ChainstateManager& chainman,
+                                                std::optional<bool> is_basic_override = std::nullopt);
+
 /** Determine the masternode reward era for the block following pindexPrev. */
 MnRewardEra GetMnRewardEraAfter(const CBlockIndex* pindexPrev, const ChainstateManager& chainman);
 
diff --git a/test/functional/feature_masternode_payout_shares.py b/test/functional/feature_masternode_payout_shares.py
index c8a0617145c3..35e6467f6f2e 100755
--- a/test/functional/feature_masternode_payout_shares.py
+++ b/test/functional/feature_masternode_payout_shares.py
@@ -133,11 +133,11 @@ def run_test(self):
         mn.set_params(proTxHash=protx_hash)
 
         raw = node.getrawtransaction(protx_hash, 1)
-        assert_equal(raw["proRegTx"]["version"], 4)
+        assert_equal(raw["proRegTx"]["version"], 3)
         assert_equal(payout_address_rewards(raw["proRegTx"]["payouts"]), payouts)
 
         info = node.protx("info", protx_hash)
-        assert_equal(info["state"]["version"], 4)
+        assert_equal(info["state"]["version"], 3)
         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}")
@@ -201,7 +201,7 @@ def shortpay_payout2(coinbase):
         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(update_raw["proUpRegTx"]["version"], 3)
         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)
 
@@ -221,7 +221,7 @@ def shortpay_payout2(coinbase):
         self.generate(node, 1, sync_fun=self.no_op)
 
         info = node.protx("info", protx_hash)
-        assert_equal(info["state"]["version"], 4)
+        assert_equal(info["state"]["version"], 3)
         assert_equal(payout_address_rewards(info["state"]["payouts"]), updated_payouts)
 
         gbt_payees = [p for p in node.getblocktemplate()["masternode"] if p["script"] != "6a"]
@@ -262,7 +262,7 @@ def shortpay_payout2(coinbase):
         self.generate(node, 1, sync_fun=self.no_op)
 
         info = node.protx("info", protx_hash)
-        assert_equal(info["state"]["version"], 4)
+        assert_equal(info["state"]["version"], 3)
         assert_equal(payout_address_rewards(info["state"]["payouts"]), updated_payouts)
 
 
diff --git a/test/functional/feature_dip3_v19.py b/test/functional/feature_protx_version.py
similarity index 64%
rename from test/functional/feature_dip3_v19.py
rename to test/functional/feature_protx_version.py
index f1010dcad0ac..1c3691f8bad0 100755
--- a/test/functional/feature_dip3_v19.py
+++ b/test/functional/feature_protx_version.py
@@ -4,9 +4,10 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 '''
-feature_dip3_v19.py
+feature_protx_version.py
 
-Checks DIP3 for v19
+Checks ProTx versioning across the v19 (basic BLS) and v24 (extended
+addresses) forks.
 
 '''
 from io import BytesIO
@@ -19,7 +20,8 @@
     MasternodeInfo,
 )
 from test_framework.util import (
-    assert_equal
+    assert_equal,
+    softfork_active,
 )
 
 
@@ -44,7 +46,7 @@ def getmnlistdiff(self, base_block_hash, block_hash):
         return self.last_mnlistdiff
 
 
-class DIP3V19Test(DashTestFramework):
+class ProTxVersionTest(DashTestFramework):
     def add_options(self, parser):
         self.add_wallet_options(parser)
 
@@ -52,6 +54,7 @@ def set_test_params(self):
         self.extra_args = [[
             '-deprecatedrpc=legacy_mn',
             '-testactivationheight=v19@200',
+            f'-vbparams=v24:{self.mocktime}:999999999999:450:10:8:6:5:0',
         ]] * 6
         self.set_dash_test_params(6, 5, evo_count=2, extra_args=self.extra_args)
 
@@ -74,6 +77,11 @@ def run_test(self):
         extra_legacy_mn: MasternodeInfo = self.dynamically_add_masternode()
         assert extra_legacy_mn is not None
 
+        # A second legacy-scheme masternode kept alive (never revoked) until v24 activates, so that
+        # the update_registrar migration path (legacy state -> basic scheme) can be exercised below.
+        migrate_legacy_mn: MasternodeInfo = self.dynamically_add_masternode()
+        assert migrate_legacy_mn is not None
+
         mn_list_before = self.nodes[0].masternodelist()
         pubkeyoperator_list_before = set([mn_list_before[e]["pubkeyoperator"] for e in mn_list_before])
 
@@ -121,6 +129,12 @@ def run_test(self):
         for i in range(6):
             new_mn: MasternodeInfo = self.dynamically_add_masternode(evo=False, rnd=(10 + i))
             assert new_mn is not None
+            if i == 0:
+                # Kept at its basic (v2) state and revoked after v24 to check the version is preserved
+                basic_mn = new_mn
+            if i == 1:
+                # Kept at its basic (v2) state and update_service'd after v24 to check the payout is preserved
+                payout_mn = new_mn
 
         # mine more quorums and make sure everything still works
         prev_quorum = None
@@ -130,6 +144,87 @@ def run_test(self):
 
         self.wait_for_chainlocked_block_all_nodes(self.nodes[0].getbestblockhash())
 
+        self.test_protx_v24_versioning(new_mn, migrate_legacy_mn, basic_mn, payout_mn)
+
+    def test_protx_v24_versioning(self, mn: MasternodeInfo, legacy_mn: MasternodeInfo, basic_mn: MasternodeInfo, payout_mn: MasternodeInfo):
+        assert not softfork_active(self.nodes[0], 'v24')
+        self.activate_by_name('v24', slow_mode=False)
+        self.log.info("Activated v24 at height:" + str(self.nodes[0].getblockcount()))
+
+        node = self.nodes[0]
+
+        self.log.info("update_service bumping a basic (v2) masternode to v3 preserves its owner payout")
+        state = node.protx('info', payout_mn.proTxHash)['state']
+        assert_equal(state['version'], 2)
+        payout_before = state['payoutAddress']
+        node.sendtoaddress(payout_mn.fundsAddr, 1)
+        self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
+        self.generate(node, 1)
+        payout_mn.update_service(node, submit=True, addrs_core_p2p=[f'127.0.0.1:{payout_mn.nodePort}'])
+        self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
+        self.generate(node, 1)
+        state = node.protx('info', payout_mn.proTxHash)['state']
+        assert_equal(state['version'], 3)
+        assert_equal([p['address'] for p in state['payouts']], [payout_before])
+        node.sendtoaddress(mn.fundsAddr, 1)
+        self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
+        self.generate(node, 1)
+
+        self.log.info("A basic-scheme masternode reports version 2 before any post-v24 update")
+        assert_equal(node.protx('info', mn.proTxHash)['state']['version'], 2)
+
+        self.log.info("A v3 ProUpRegTx reusing the basic operator key is accepted, but leaves the "
+                      "stored masternode version at 3 even no operator key change took place")
+        protx_result = mn.update_registrar(node, submit=True, fundsAddr=mn.fundsAddr)
+        self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
+        tip = self.generate(node, 1)[0]
+        assert_equal(node.getrawtransaction(protx_result, 1, tip)['proUpRegTx']['version'], 3)
+        assert_equal(node.protx('info', mn.proTxHash)['state']['version'], 3)
+
+        self.log.info("Migration v1 [legacy] protx masternode to v3 by update-registar")
+        assert_equal(node.protx('info', legacy_mn.proTxHash)['state']['version'], 1)
+        node.sendtoaddress(legacy_mn.fundsAddr, 1)
+        self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
+        self.generate(node, 1)
+        # Switch to a fresh basic-scheme operator key and the non-legacy update_registrar RPC
+        legacy_mn.legacy = False
+        new_operator = node.bls('generate') # basic (non-legacy) scheme
+        legacy_mn.pubKeyOperator = new_operator['public']
+        legacy_mn.keyOperator = new_operator['secret']
+        migrate_result = legacy_mn.update_registrar(node, submit=True, fundsAddr=legacy_mn.fundsAddr)
+        self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
+        tip = self.generate(node, 1, sync_fun=self.no_op)[0]
+        assert_equal(node.getrawtransaction(migrate_result, 1, tip)['proUpRegTx']['version'], 3)
+        assert_equal(node.protx('info', legacy_mn.proTxHash)['state']['version'], 3)
+        # Changing the operator key PoSe-bans the masternode, which results in disconnects. Wait for
+        # them to happen and then reconnect its node back to let sync_all finish correctly.
+        assert legacy_mn.nodeIdx is not None
+        self.wait_until(lambda: self.nodes[legacy_mn.nodeIdx].getconnectioncount() == 0)
+        self.connect_nodes(legacy_mn.nodeIdx, 0)
+        self.sync_all()
+
+        self.test_revoke_protx(mn.nodeIdx, mn)
+
+        self.log.info("Masternode list reloads from disk identically after the v3 updates")
+        list_before = self.nodes[1].masternodelist()
+        self.restart_node(1, extra_args=self.extra_args[1])
+        self.connect_nodes(0, 1)
+        self.connect_nodes(1, 2)
+        assert_equal(self.nodes[1].masternodelist(), list_before)
+
+        self.log.info("Revoking a still-v2 (BasicBLS) masternode after v24 preserves its state version "
+                      "instead of silently downgrading it to LegacyBLS via the operator-field reset")
+        assert_equal(node.protx('info', basic_mn.proTxHash)['state']['version'], 2)
+        self.test_revoke_protx(basic_mn.nodeIdx, basic_mn)
+        # The v3 ProUpRevTx is applied against a v2 state, so max(old, tx) keeps the version at 3, not 1
+        assert_equal(node.protx('info', basic_mn.proTxHash)['state']['version'], 3)
+
+        list_before = self.nodes[1].masternodelist()
+        self.restart_node(1, extra_args=self.extra_args[1])
+        self.connect_nodes(0, 1)
+        self.connect_nodes(1, 2)
+        assert_equal(self.nodes[1].masternodelist(), list_before)
+
     def test_revoke_protx(self, node_idx, revoke_mn: MasternodeInfo):
         funds_address = self.nodes[0].getnewaddress()
         fund_txid = self.nodes[0].sendtoaddress(funds_address, 1)
@@ -224,4 +319,4 @@ def test_getmnlistdiff_base(self, base_block_hash, block_hash):
 
 
 if __name__ == '__main__':
-    DIP3V19Test().main()
+    ProTxVersionTest().main()
diff --git a/test/functional/rpc_netinfo.py b/test/functional/rpc_netinfo.py
index d02d7e2bf811..2888095c35f8 100755
--- a/test/functional/rpc_netinfo.py
+++ b/test/functional/rpc_netinfo.py
@@ -34,7 +34,6 @@
 # See ProTxVersion in src/evo/providertx.h
 PROTXVER_BASIC = 2
 PROTXVER_EXTADDR = 3
-PROTXVER_MULTIPAYOUT = 4
 
 # Sample domains
 DOMAINS_CLR = [
@@ -528,7 +527,7 @@ def empty_common(grt_dict):
 
         # 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_MULTIPAYOUT)
+        assert_equal(grt_proregtx['version'], PROTXVER_EXTADDR)
 
         # Test reporting for extended addresses
         empty_common(grt_proregtx)
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index e303013a6b75..3df3cccb4ea2 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -123,7 +123,7 @@
     'p2p_tx_download.py',
     'wallet_dump.py --legacy-wallet',
     'feature_multikeysporks.py',
-    'feature_dip3_v19.py',
+    'feature_protx_version.py',
     'feature_asset_locks.py', # NOTE: needs dash_hash to pass
     'feature_llmq_connections.py', # NOTE: needs dash_hash to pass
     'feature_llmq_is_retroactive.py', # NOTE: needs dash_hash to pass
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 5ae86e5b7bdb..b6353d8b70d5 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -29,12 +29,9 @@
     "consensus/tx_verify -> evo/assetlocktx -> llmq/commitment -> validation -> txmempool -> consensus/tx_verify",
     "evo/assetlocktx -> llmq/commitment -> validation -> txmempool -> evo/assetlocktx",
     "evo/chainhelper -> evo/creditpool -> validation -> evo/chainhelper",
-    "evo/deterministicmns -> evo/providertx -> validation -> evo/deterministicmns",
-    "evo/deterministicmns -> evo/providertx -> validation -> txmempool -> evo/deterministicmns",
-    "evo/deterministicmns -> evo/providertx -> validation -> masternode/payments -> evo/deterministicmns",
-    "evo/netinfo -> evo/providertx -> evo/netinfo",
-    "evo/netinfo -> evo/providertx -> validation -> txmempool -> evo/netinfo",
-    "evo/providertx -> validation -> txmempool -> evo/providertx",
+    "evo/deterministicmns -> node/blockstorage -> validation -> evo/deterministicmns",
+    "evo/deterministicmns -> node/blockstorage -> validation -> masternode/payments -> evo/deterministicmns",
+    "evo/deterministicmns -> node/blockstorage -> validation -> txmempool -> evo/deterministicmns",
     "evo/smldiff -> llmq/blockprocessor -> llmq/utils -> llmq/snapshot -> evo/smldiff",
     "evo/specialtxman -> validation -> evo/specialtxman",
     "governance/superblock -> validation -> masternode/payments -> governance/superblock",