diff --git a/contrib/seeds/makeseeds.py b/contrib/seeds/makeseeds.py
index 72dc8fb6a3c9..b00087164b52 100755
--- a/contrib/seeds/makeseeds.py
+++ b/contrib/seeds/makeseeds.py
@@ -164,7 +164,7 @@ def main():
     mns = filtermulticollateraladdress(mns)
     mns = filtermultipayoutaddress(mns)
     # Extract IPs
-    ips = [parseip(mn['state']['addresses'][0]) for mn in mns]
+    ips = [parseip(mn['state']['addresses']['core_p2p'][0]) for mn in mns]
     for onion in onions:
         parsed = parseip(onion)
         if parsed is not None:
diff --git a/doc/release-notes-6666.md b/doc/release-notes-6666.md
new file mode 100644
index 000000000000..2043e461c923
--- /dev/null
+++ b/doc/release-notes-6666.md
@@ -0,0 +1,65 @@
+Notable Changes
+---------------
+
+* Dash Core has added support for the ability to register multiple addr:port pairs to a masternode and for specifying
+  distinct addresses for platform P2P and platform HTTPS endpoints. The consensus and format changes needed to enable
+  this capability is referred to as "extended addresses" and is enabled by the deployment of the v23 fork, affecting
+  new masternode registrations and service updates to basic BLS masternodes.
+  * Operators must upgrade from legacy BLS scheme to basic BLS scheme before utilizing extended address capabilities
+
+Additional Notes
+----------------
+
+* While the field `service` is deprecated (see dash#6665), its effective value can be obtained by querying
+  `addresses['core_p2p'][0]`.
+
+* If the masternode is eligible for extended addresses, operators may register non-IPv4 addresses, subject to validation
+  and consensus rules.
+
+Updated RPCs
+------------
+
+* The input field `platformP2PPort` has been renamed to `platformP2PAddrs`. In addition to numeric inputs (i.e. ports),
+  the field can now accept a string (i.e. an addr:port pair) and arrays of strings (i.e. multiple addr:port pairs),
+  subject to validation rules.
+
+* The input field `platformHTTPPort` has been renamed to `platformHTTPSAddrs`. In addition to numeric inputs (i.e. ports),
+  the field can now accept a string (i.e. an addr:port pair) and arrays of strings (i.e. multiple addr:port pairs),
+  subject to validation rules.
+
+* The field `addresses` will now also report on platform P2P and platform HTTPS endpoints as `addresses['platform_p2p']`
+  and `addresses['platform_https']` respectively.
+  * On payloads before extended addresses, if a masternode update affects `platformP2PPort` and/or `platformHTTPPort`
+    but does not affect `netInfo`, `protx listdiff` does not contain enough information to report on the masternode's
+    address and will report the changed port paired with the dummy address `255.255.255.255`.
+
+    This does not affect `protx listdiff` queries where `netInfo` was updated or diffs relating to masternodes that
+    have upgraded to extended addresses.
+
+* If the masternode is eligible for extended addresses, `protx register{,_evo}` and `register_fund{,_evo}` will continue
+  allowing `coreP2PAddrs` to be left blank, as long as `platformP2PAddrs` and `platformHTTPSAddrs` are _also_ left blank.
+  * Attempting to populate any three address fields will make populating all fields mandatory.
+  * This does not affect nodes ineligible for extended addresses (i.e. all nodes before fork activation or legacy BLS nodes)
+    and they will have to continue specifying `platformP2PAddrs` and `platformHTTPSAddrs` even if they wish to keep
+    `coreP2PAddrs` blank.
+
+* If the masternode is eligible for extended addresses, `protx register{,_evo}` and `register_fund{,_evo}` will no longer
+  default to the core P2P port if a port is not specified in the addr:port pair. All ports must be specified explicitly.
+  * This does not affect nodes ineligible for extended addresses, continuing to default to the core P2P port if provided an
+    addr without a port.
+
+* `protx register{,_evo}` and `register_fund{,_evo}` will continue to allow specifying only the port number for `platformP2PAddrs`
+  and `platformHTTPSAddrs`, pairing it with the address from the first `coreP2PAddrs` entry. This mirrors existing behavior.
+  * This method of entry may not be available in future releases of Dash Core and operators are recommended to switch over to
+    explicitly specifying (arrays of) addr:port strings for all address fields.
+
+* When reporting on extended address payloads, `platformP2PPort` and `platformHTTPPort` will read the port value from
+  `netInfo[PLATFORM_P2P][0]` and `netInfo[PLATFORM_HTTPS][0]` respectively as both fields are subsumed into `netInfo`.
+  * If `netInfo` is blank (which is allowed by ProRegTx), `platformP2PPort` and `platformHTTPPort` will report `-1` to indicate
+    that the port number cannot be determined.
+  * `protx listdiff` will not report `platformP2PPort` or `platformHTTPPort` if the legacy fields were not updated (i.e.
+    changes to `netInfo` will not translate into reporting). This is because `platformP2PPort` or `platformHTTPPort` have
+    dedicated diff flags and post-consolidation, all changes are now affected by `netInfo`'s diff flag.
+
+    To avoid the perception of changes to fields that not serialized by extended address payloads, data from `netInfo` will
+    not be translated for this RPC call.
diff --git a/src/coinjoin/client.cpp b/src/coinjoin/client.cpp
index 543bce8f0a32..38e08dea59d1 100644
--- a/src/coinjoin/client.cpp
+++ b/src/coinjoin/client.cpp
@@ -14,6 +14,7 @@
 #include <net.h>
 #include <net_processing.h>
 #include <netmessagemaker.h>
+#include <rpc/evo_util.h>
 #include <shutdown.h>
 #include <util/check.h>
 #include <util/irange.h>
@@ -1875,7 +1876,7 @@ void CCoinJoinClientSession::GetJsonInfo(UniValue& obj) const
         if (m_wallet->chain().rpcEnableDeprecated("service")) {
             obj.pushKV("service", mixingMasternode->pdmnState->netInfo->GetPrimary().ToStringAddrPort());
         }
-        obj.pushKV("addresses", mixingMasternode->pdmnState->netInfo->ToJson());
+        obj.pushKV("addrs_core_p2p", mixingMasternode->pdmnState->netInfo->ToJson(NetInfoPurpose::CORE_P2P));
     }
     obj.pushKV("denomination", ValueFromAmount(CoinJoin::DenominationToAmount(nSessionDenom)));
     obj.pushKV("state", GetStateString());
diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index bab2073d0f44..97c0104a2011 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -13,6 +13,7 @@
 #include <evo/simplifiedmns.h>
 #include <evo/smldiff.h>
 #include <llmq/commitment.h>
+#include <rpc/evo_util.h>
 
 #include <univalue.h>
 
@@ -74,7 +75,7 @@
     if (IsServiceDeprecatedRPCEnabled()) {
         ret.pushKV("service", netInfo->GetPrimary().ToStringAddrPort());
     }
-    ret.pushKV("addresses", netInfo->ToJson());
+    ret.pushKV("addresses", GetNetInfoWithLegacyFields(*this, nType));
     ret.pushKV("ownerAddress", EncodeDestination(PKHash(keyIDOwner)));
     ret.pushKV("votingAddress", EncodeDestination(PKHash(keyIDVoting)));
     if (CTxDestination dest; ExtractDestination(scriptPayout, dest)) {
@@ -84,8 +85,8 @@
     ret.pushKV("operatorReward", (double)nOperatorReward / 100);
     if (nType == MnType::Evo) {
         ret.pushKV("platformNodeID", platformNodeID.ToString());
-        ret.pushKV("platformP2PPort", platformP2PPort);
-        ret.pushKV("platformHTTPPort", platformHTTPPort);
+        ret.pushKV("platformP2PPort", GetPlatformPort</*is_p2p=*/true>(*this));
+        ret.pushKV("platformHTTPPort", GetPlatformPort</*is_p2p=*/false>(*this));
     }
     ret.pushKV("inputsHash", inputsHash.ToString());
     return ret;
@@ -124,14 +125,14 @@
     if (IsServiceDeprecatedRPCEnabled()) {
         ret.pushKV("service", netInfo->GetPrimary().ToStringAddrPort());
     }
-    ret.pushKV("addresses", netInfo->ToJson());
+    ret.pushKV("addresses", GetNetInfoWithLegacyFields(*this, nType));
     if (CTxDestination dest; ExtractDestination(scriptOperatorPayout, dest)) {
         ret.pushKV("operatorPayoutAddress", EncodeDestination(dest));
     }
     if (nType == MnType::Evo) {
         ret.pushKV("platformNodeID", platformNodeID.ToString());
-        ret.pushKV("platformP2PPort", platformP2PPort);
-        ret.pushKV("platformHTTPPort", platformHTTPPort);
+        ret.pushKV("platformP2PPort", GetPlatformPort</*is_p2p=*/true>(*this));
+        ret.pushKV("platformHTTPPort", GetPlatformPort</*is_p2p=*/false>(*this));
     }
     ret.pushKV("inputsHash", inputsHash.ToString());
     return ret;
@@ -164,12 +165,12 @@
     if (IsServiceDeprecatedRPCEnabled()) {
         obj.pushKV("service", netInfo->GetPrimary().ToStringAddrPort());
     }
-    obj.pushKV("addresses", netInfo->ToJson());
+    obj.pushKV("addresses", GetNetInfoWithLegacyFields(*this, nType));
     obj.pushKV("pubKeyOperator", pubKeyOperator.ToString());
     obj.pushKV("votingAddress", EncodeDestination(PKHash(keyIDVoting)));
     obj.pushKV("isValid", isValid);
     if (nType == MnType::Evo) {
-        obj.pushKV("platformHTTPPort", platformHTTPPort);
+        obj.pushKV("platformHTTPPort", GetPlatformPort</*is_p2p=*/false>(*this));
         obj.pushKV("platformNodeID", platformNodeID.ToString());
     }
 
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index 08468ca9c5b9..3b014a2173c6 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -432,13 +432,12 @@ void CDeterministicMNList::AddMN(const CDeterministicMNCPtr& dmn, bool fBumpTota
         throw(std::runtime_error(strprintf("%s: Can't add a masternode %s with a duplicate collateralOutpoint=%s", __func__,
                 dmn->proTxHash.ToString(), dmn->collateralOutpoint.ToStringShort())));
     }
-    for (const NetInfoEntry& entry : dmn->pdmnState->netInfo->GetEntries()) {
-        if (const auto& service_opt{entry.GetAddrPort()}; service_opt.has_value()) {
-            const CService& service{service_opt.value()};
-            if (!AddUniqueProperty(*dmn, service)) {
+    for (const auto& entry : dmn->pdmnState->netInfo->GetEntries()) {
+        if (const auto service_opt{entry.GetAddrPort()}) {
+            if (!AddUniqueProperty(*dmn, *service_opt)) {
                 mnUniquePropertyMap = mnUniquePropertyMapSaved;
-                throw std::runtime_error(strprintf("%s: Can't add a masternode %s with a duplicate address=%s",
-                                                   __func__, dmn->proTxHash.ToString(), service.ToStringAddrPort()));
+                throw std::runtime_error(strprintf("%s: Can't add a masternode %s with a duplicate address=%s", __func__,
+                                                   dmn->proTxHash.ToString(), service_opt->ToStringAddrPort()));
             }
         } else {
             mnUniquePropertyMap = mnUniquePropertyMapSaved;
@@ -489,21 +488,19 @@ void CDeterministicMNList::UpdateMN(const CDeterministicMN& oldDmn, const std::s
             // We track each individual entry in netInfo as opposed to netInfo itself (preventing us from
             // using UpdateUniqueProperty()), so we need to successfully purge all old entries and insert
             // new entries to successfully update.
-            for (const NetInfoEntry& old_entry : oldInfo->GetEntries()) {
-                if (const auto& service_opt{old_entry.GetAddrPort()}) {
-                    const CService& service{service_opt.value()};
-                    if (!DeleteUniqueProperty(dmn, service)) {
+            for (const auto& old_entry : oldInfo->GetEntries()) {
+                if (const auto service_opt{old_entry.GetAddrPort()}) {
+                    if (!DeleteUniqueProperty(dmn, *service_opt)) {
                         return "internal error"; // This shouldn't be possible
                     }
                 } else {
                     return "invalid address";
                 }
             }
-            for (const NetInfoEntry& new_entry : newInfo->GetEntries()) {
-                if (const auto& service_opt{new_entry.GetAddrPort()}) {
-                    const CService& service{service_opt.value()};
-                    if (!AddUniqueProperty(dmn, service)) {
-                        return strprintf("duplicate (%s)", service.ToStringAddrPort());
+            for (const auto& new_entry : newInfo->GetEntries()) {
+                if (const auto service_opt{new_entry.GetAddrPort()}) {
+                    if (!AddUniqueProperty(dmn, *service_opt)) {
+                        return strprintf("duplicate (%s)", service_opt->ToStringAddrPort());
                     }
                 } else {
                     return "invalid address";
@@ -578,13 +575,12 @@ void CDeterministicMNList::RemoveMN(const uint256& proTxHash)
         throw(std::runtime_error(strprintf("%s: Can't delete a masternode %s with a collateralOutpoint=%s", __func__,
                 proTxHash.ToString(), dmn->collateralOutpoint.ToStringShort())));
     }
-    for (const NetInfoEntry& entry : dmn->pdmnState->netInfo->GetEntries()) {
-        if (const auto& service_opt{entry.GetAddrPort()}; service_opt.has_value()) {
-            const CService& service{service_opt.value()};
-            if (!DeleteUniqueProperty(*dmn, service)) {
+    for (const auto& entry : dmn->pdmnState->netInfo->GetEntries()) {
+        if (const auto service_opt{entry.GetAddrPort()}) {
+            if (!DeleteUniqueProperty(*dmn, *service_opt)) {
                 mnUniquePropertyMap = mnUniquePropertyMapSaved;
                 throw std::runtime_error(strprintf("%s: Can't delete a masternode %s with an address=%s", __func__,
-                                                   proTxHash.ToString(), service.ToStringAddrPort()));
+                                                   proTxHash.ToString(), service_opt->ToStringAddrPort()));
             }
         } else {
             mnUniquePropertyMap = mnUniquePropertyMapSaved;
@@ -914,6 +910,7 @@ static bool CheckService(const ProTx& proTx, TxValidationState& state)
         return true;
     // Shouldn't be possible during self-checks
     case NetInfoStatus::BadInput:
+    case NetInfoStatus::Duplicate:
     case NetInfoStatus::MaxLimit:
         assert(false);
     } // no default case, so the compiler can warn about missing cases
@@ -921,39 +918,41 @@ static bool CheckService(const ProTx& proTx, TxValidationState& state)
 }
 
 template <typename ProTx>
-static bool CheckPlatformFields(const ProTx& proTx, TxValidationState& state)
+static bool CheckPlatformFields(const ProTx& proTx, bool is_extended_addr, TxValidationState& state)
 {
     if (proTx.platformNodeID.IsNull()) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-nodeid");
     }
 
-    // TODO: use real args here
-    static int mainnetPlatformP2PPort = CreateChainParams(ArgsManager{}, CBaseChainParams::MAIN)->GetDefaultPlatformP2PPort();
-    if (Params().NetworkIDString() == CBaseChainParams::MAIN) {
-        if (proTx.platformP2PPort != mainnetPlatformP2PPort) {
+    if (is_extended_addr) {
+        // platformHTTPPort and platformP2PPort have been subsumed by netInfo. They should always be zero.
+        if (proTx.platformP2PPort != 0) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-p2p-port");
         }
+        if (proTx.platformHTTPPort != 0) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
+        }
+        return true;
     }
 
-    // TODO: use real args here
-    static int mainnetPlatformHTTPPort = CreateChainParams(ArgsManager{}, CBaseChainParams::MAIN)->GetDefaultPlatformHTTPPort();
-    if (Params().NetworkIDString() == CBaseChainParams::MAIN) {
-        if (proTx.platformHTTPPort != mainnetPlatformHTTPPort) {
+    if (::IsNodeOnMainnet()) {
+        if (proTx.platformP2PPort != ::MainParams().GetDefaultPlatformP2PPort()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-p2p-port");
+        }
+        if (proTx.platformHTTPPort != ::MainParams().GetDefaultPlatformHTTPPort()) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
         }
     }
-
-    // TODO: use real args here
-    static int mainnetDefaultP2PPort = CreateChainParams(ArgsManager{}, CBaseChainParams::MAIN)->GetDefaultPort();
-    if (proTx.platformP2PPort == mainnetDefaultP2PPort) {
+    if (proTx.platformP2PPort == ::MainParams().GetDefaultPort()) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-p2p-port");
     }
-    if (proTx.platformHTTPPort == mainnetDefaultP2PPort) {
+    if (proTx.platformHTTPPort == ::MainParams().GetDefaultPort()) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
     }
 
-    if (proTx.platformP2PPort == proTx.platformHTTPPort || proTx.platformP2PPort == proTx.netInfo->GetPrimary().GetPort() ||
-        proTx.platformHTTPPort == proTx.netInfo->GetPrimary().GetPort()) {
+    const uint16_t core_port{proTx.netInfo->GetPrimary().GetPort()};
+    if (proTx.platformP2PPort == proTx.platformHTTPPort || proTx.platformP2PPort == core_port ||
+        proTx.platformHTTPPort == core_port) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-dup-ports");
     }
 
@@ -1065,7 +1064,7 @@ bool CheckProRegTx(CDeterministicMNManager& dmnman, const CTransaction& tx, gsl:
     }
 
     if (opt_ptx->nType == MnType::Evo) {
-        if (!CheckPlatformFields(*opt_ptx, state)) {
+        if (!CheckPlatformFields(*opt_ptx, opt_ptx->nVersion >= ProTxVersion::ExtAddr, state)) {
             return false;
         }
     }
@@ -1119,11 +1118,10 @@ bool CheckProRegTx(CDeterministicMNManager& dmnman, const CTransaction& tx, gsl:
         auto mnList = dmnman.GetListForBlock(pindexPrev);
 
         // only allow reusing of addresses when it's for the same collateral (which replaces the old MN)
-        for (const NetInfoEntry& entry : opt_ptx->netInfo->GetEntries()) {
-            if (const auto& service_opt{entry.GetAddrPort()}; service_opt.has_value()) {
-                const CService& service{service_opt.value()};
-                if (mnList.HasUniqueProperty(service) &&
-                    mnList.GetUniquePropertyMN(service)->collateralOutpoint != collateralOutpoint) {
+        for (const auto& entry : opt_ptx->netInfo->GetEntries()) {
+            if (const auto service_opt{entry.GetAddrPort()}) {
+                if (mnList.HasUniqueProperty(*service_opt) &&
+                    mnList.GetUniquePropertyMN(*service_opt)->collateralOutpoint != collateralOutpoint) {
                     return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-netinfo-entry");
                 }
             } else {
@@ -1185,7 +1183,7 @@ bool CheckProUpServTx(CDeterministicMNManager& dmnman, const CTransaction& tx, g
     }
 
     if (opt_ptx->nType == MnType::Evo) {
-        if (!CheckPlatformFields(*opt_ptx, state)) {
+        if (!CheckPlatformFields(*opt_ptx, opt_ptx->nVersion >= ProTxVersion::ExtAddr, state)) {
             return false;
         }
     }
@@ -1202,10 +1200,10 @@ bool CheckProUpServTx(CDeterministicMNManager& dmnman, const CTransaction& tx, g
     }
 
     // don't allow updating to addresses already used by other MNs
-    for (const NetInfoEntry& entry : opt_ptx->netInfo->GetEntries()) {
-        if (const auto& service_opt{entry.GetAddrPort()}; service_opt.has_value()) {
-            const CService& service{service_opt.value()};
-            if (mnList.HasUniqueProperty(service) && mnList.GetUniquePropertyMN(service)->proTxHash != opt_ptx->proTxHash) {
+    for (const auto& entry : opt_ptx->netInfo->GetEntries()) {
+        if (const auto service_opt{entry.GetAddrPort()}) {
+            if (mnList.HasUniqueProperty(*service_opt) &&
+                mnList.GetUniquePropertyMN(*service_opt)->proTxHash != opt_ptx->proTxHash) {
                 return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-netinfo-entry");
             }
         } else {
diff --git a/src/evo/deterministicmns.h b/src/evo/deterministicmns.h
index 9c106c5fe941..db6fa318b296 100644
--- a/src/evo/deterministicmns.h
+++ b/src/evo/deterministicmns.h
@@ -434,6 +434,7 @@ class CDeterministicMNList
 #define DMNL_NO_TEMPLATE(name) \
     static_assert(!std::is_same_v<std::decay_t<T>, name>, "GetUniquePropertyHash cannot be templated against " #name)
         DMNL_NO_TEMPLATE(CBLSPublicKey);
+        DMNL_NO_TEMPLATE(ExtNetInfo);
         DMNL_NO_TEMPLATE(MnNetInfo);
         DMNL_NO_TEMPLATE(NetInfoEntry);
         DMNL_NO_TEMPLATE(NetInfoInterface);
diff --git a/src/evo/dmnstate.cpp b/src/evo/dmnstate.cpp
index dae0db688e4e..7b08a36c3b9e 100644
--- a/src/evo/dmnstate.cpp
+++ b/src/evo/dmnstate.cpp
@@ -6,6 +6,9 @@
 
 #include <script/standard.h>
 
+#include <evo/netinfo.h>
+#include <rpc/evo_util.h>
+
 #include <univalue.h>
 
 std::string CDeterministicMNState::ToString() const
@@ -22,12 +25,11 @@ std::string CDeterministicMNState::ToString() const
 
     return strprintf("CDeterministicMNState(nVersion=%d, nRegisteredHeight=%d, nLastPaidHeight=%d, nPoSePenalty=%d, "
                      "nPoSeRevivedHeight=%d, nPoSeBanHeight=%d, nRevocationReason=%d, "
-                     "ownerAddress=%s, pubKeyOperator=%s, votingAddress=%s, payoutAddress=%s, "
-                     "operatorPayoutAddress=%s)\n"
-                     "  %s",
+                     "ownerAddress=%s, pubKeyOperator=%s, votingAddress=%s, netInfo=%s, payoutAddress=%s, "
+                     "operatorPayoutAddress=%s)\n",
                      nVersion, nRegisteredHeight, nLastPaidHeight, nPoSePenalty, nPoSeRevivedHeight, nPoSeBanHeight,
                      nRevocationReason, EncodeDestination(PKHash(keyIDOwner)), pubKeyOperator.ToString(),
-                     EncodeDestination(PKHash(keyIDVoting)), payoutAddress, operatorPayoutAddress, netInfo->ToString());
+                     EncodeDestination(PKHash(keyIDVoting)), netInfo->ToString(), payoutAddress, operatorPayoutAddress);
 }
 
 UniValue CDeterministicMNState::ToJson(MnType nType) const
@@ -37,7 +39,7 @@ UniValue CDeterministicMNState::ToJson(MnType nType) const
     if (IsServiceDeprecatedRPCEnabled()) {
         obj.pushKV("service", netInfo->GetPrimary().ToStringAddrPort());
     }
-    obj.pushKV("addresses", netInfo->ToJson());
+    obj.pushKV("addresses", GetNetInfoWithLegacyFields(*this, nType));
     obj.pushKV("registeredHeight", nRegisteredHeight);
     obj.pushKV("lastPaidHeight", nLastPaidHeight);
     obj.pushKV("consecutivePayments", nConsecutivePayments);
@@ -49,8 +51,8 @@ UniValue CDeterministicMNState::ToJson(MnType nType) const
     obj.pushKV("votingAddress", EncodeDestination(PKHash(keyIDVoting)));
     if (nType == MnType::Evo) {
         obj.pushKV("platformNodeID", platformNodeID.ToString());
-        obj.pushKV("platformP2PPort", platformP2PPort);
-        obj.pushKV("platformHTTPPort", platformHTTPPort);
+        obj.pushKV("platformP2PPort", GetPlatformPort</*is_p2p=*/true>(*this));
+        obj.pushKV("platformHTTPPort", GetPlatformPort</*is_p2p=*/false>(*this));
     }
 
     CTxDestination dest;
@@ -74,7 +76,6 @@ UniValue CDeterministicMNStateDiff::ToJson(MnType nType) const
         if (IsServiceDeprecatedRPCEnabled()) {
             obj.pushKV("service", state.netInfo->GetPrimary().ToStringAddrPort());
         }
-        obj.pushKV("addresses", state.netInfo->ToJson());
     }
     if (fields & Field_nRegisteredHeight) {
         obj.pushKV("registeredHeight", state.nRegisteredHeight);
@@ -129,5 +130,37 @@ UniValue CDeterministicMNStateDiff::ToJson(MnType nType) const
             obj.pushKV("platformHTTPPort", state.platformHTTPPort);
         }
     }
+    {
+        const bool has_netinfo = (fields & Field_netInfo);
+
+        UniValue netInfoObj(UniValue::VOBJ);
+        if (has_netinfo) {
+            netInfoObj = state.netInfo->ToJson();
+        }
+        if (nType == MnType::Evo && (!has_netinfo || !state.netInfo->CanStorePlatform())) {
+            auto unknownAddr = [](uint16_t port) -> UniValue {
+                UniValue obj(UniValue::VARR);
+                // We don't know what the address is because it wasn't changed in the
+                // diff but we still need to report the port number in addr:port format
+                obj.push_back(strprintf("255.255.255.255:%d", port));
+                return obj;
+            };
+            if (fields & Field_platformP2PPort) {
+                netInfoObj.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_P2P).data(),
+                                  (has_netinfo)
+                                      ? ArrFromService(CService(state.netInfo->GetPrimary(), state.platformP2PPort))
+                                      : unknownAddr(state.platformP2PPort));
+            }
+            if (fields & Field_platformHTTPPort) {
+                netInfoObj.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_HTTPS).data(),
+                                  (has_netinfo)
+                                      ? ArrFromService(CService(state.netInfo->GetPrimary(), state.platformHTTPPort))
+                                      : unknownAddr(state.platformHTTPPort));
+            }
+        }
+        if (!netInfoObj.empty()) {
+            obj.pushKV("addresses", netInfoObj);
+        }
+    }
     return obj;
 }
diff --git a/src/evo/dmnstate.h b/src/evo/dmnstate.h
index 380bac93ea0e..d63460b2d931 100644
--- a/src/evo/dmnstate.h
+++ b/src/evo/dmnstate.h
@@ -102,9 +102,12 @@ class CDeterministicMNState
                               obj.nVersion >= ProTxVersion::ExtAddr),
             obj.scriptPayout,
             obj.scriptOperatorPayout,
-            obj.platformNodeID,
+            obj.platformNodeID);
+        if (obj.nVersion < ProTxVersion::ExtAddr) {
+            READWRITE(
             obj.platformP2PPort,
             obj.platformHTTPPort);
+        }
     }
 
     void ResetOperatorFields()
diff --git a/src/evo/netinfo.cpp b/src/evo/netinfo.cpp
index 03a258c4f777..bbc7af3e1270 100644
--- a/src/evo/netinfo.cpp
+++ b/src/evo/netinfo.cpp
@@ -9,6 +9,7 @@
 #include <netbase.h>
 #include <span.h>
 #include <util/check.h>
+#include <util/string.h>
 #include <util/system.h>
 
 #include <univalue.h>
@@ -16,18 +17,9 @@
 namespace {
 static std::unique_ptr<const CChainParams> g_main_params{nullptr};
 static std::once_flag g_main_params_flag;
-static const CService empty_service{};
 
 static constexpr std::string_view SAFE_CHARS_IPV4{"1234567890."};
-
-bool IsNodeOnMainnet() { return Params().NetworkIDString() == CBaseChainParams::MAIN; }
-const CChainParams& MainParams()
-{
-    // TODO: use real args here
-    std::call_once(g_main_params_flag,
-                   [&]() { g_main_params = CreateChainParams(ArgsManager{}, CBaseChainParams::MAIN); });
-    return *Assert(g_main_params);
-}
+static constexpr std::string_view SAFE_CHARS_IPV4_6{"abcdefABCDEF1234567890.:[]"};
 
 bool MatchCharsFilter(std::string_view input, std::string_view filter)
 {
@@ -35,6 +27,14 @@ bool MatchCharsFilter(std::string_view input, std::string_view filter)
 }
 } // anonymous namespace
 
+bool IsNodeOnMainnet() { return Params().NetworkIDString() == CBaseChainParams::MAIN; }
+
+const CChainParams& MainParams()
+{
+    std::call_once(g_main_params_flag, [&]() { g_main_params = CreateChainParams(::gArgs, CBaseChainParams::MAIN); });
+    return *Assert(g_main_params);
+}
+
 UniValue ArrFromService(const CService& addr)
 {
     UniValue obj(UniValue::VARR);
@@ -78,7 +78,7 @@ bool NetInfoEntry::operator<(const NetInfoEntry& rhs) const
         m_data, rhs.m_data);
 }
 
-std::optional<std::reference_wrapper<const CService>> NetInfoEntry::GetAddrPort() const
+std::optional<CService> NetInfoEntry::GetAddrPort() const
 {
     if (const auto* data_ptr{std::get_if<CService>(&m_data)}; m_type == NetInfoType::Service && data_ptr) {
         ASSERT_IF_DEBUG(data_ptr->IsValid());
@@ -165,7 +165,10 @@ std::string NetInfoEntry::ToStringAddrPort() const
 
 std::shared_ptr<NetInfoInterface> NetInfoInterface::MakeNetInfo(const uint16_t nVersion)
 {
-    assert(nVersion > 0 && nVersion < ProTxVersion::ExtAddr);
+    assert(nVersion > 0);
+    if (nVersion >= ProTxVersion::ExtAddr) {
+        return std::make_shared<ExtNetInfo>();
+    }
     return std::make_shared<MnNetInfo>();
 }
 
@@ -190,9 +193,9 @@ NetInfoStatus MnNetInfo::ValidateService(const CService& service)
     return NetInfoStatus::Success;
 }
 
-NetInfoStatus MnNetInfo::AddEntry(const std::string& input)
+NetInfoStatus MnNetInfo::AddEntry(const NetInfoPurpose purpose, const std::string& input)
 {
-    if (!IsEmpty()) {
+    if (purpose != NetInfoPurpose::CORE_P2P || !IsEmpty()) {
         return NetInfoStatus::MaxLimit;
     }
 
@@ -215,23 +218,23 @@ NetInfoStatus MnNetInfo::AddEntry(const std::string& input)
     return NetInfoStatus::BadInput;
 }
 
-NetInfoList MnNetInfo::GetEntries() const
+NetInfoList MnNetInfo::GetEntries(std::optional<NetInfoPurpose> purpose_opt) const
 {
-    if (!IsEmpty()) {
+    if (!IsEmpty() && (!purpose_opt || *purpose_opt == NetInfoPurpose::CORE_P2P)) {
         ASSERT_IF_DEBUG(m_addr.GetAddrPort().has_value());
         return {m_addr};
     }
-    // If MnNetInfo is empty, we probably don't expect any entries to show up, so
-    // we return a blank set instead.
-    return {};
+    // If MnNetInfo is empty or we are given an unexpected purpose code, we don't
+    // expect any entries to show up, so we return a blank set instead.
+    return NetInfoList{};
 }
 
-const CService& MnNetInfo::GetPrimary() const
+CService MnNetInfo::GetPrimary() const
 {
-    if (const auto& service_opt{m_addr.GetAddrPort()}) {
+    if (const auto service_opt{m_addr.GetAddrPort()}) {
         return *service_opt;
     }
-    return empty_service;
+    return CService{};
 }
 
 NetInfoStatus MnNetInfo::Validate() const
@@ -242,15 +245,248 @@ NetInfoStatus MnNetInfo::Validate() const
     return ValidateService(GetPrimary());
 }
 
-UniValue MnNetInfo::ToJson() const
+UniValue MnNetInfo::ToJson(std::optional<NetInfoPurpose> purpose_opt) const
 {
-    return ArrFromService(GetPrimary());
+    if (purpose_opt) {
+        UniValue arr(UniValue::VARR);
+        for (const auto& entry : GetEntries(purpose_opt)) {
+            arr.push_back(entry.ToStringAddrPort());
+        }
+        return arr;
+    }
+
+    UniValue ret{UniValue::VOBJ};
+    if (!IsEmpty()) {
+        ret.pushKV(PurposeToString(NetInfoPurpose::CORE_P2P).data(), ArrFromService(GetPrimary()));
+    }
+    return ret;
 }
 
 std::string MnNetInfo::ToString() const
 {
-    // Extra padding to account for padding done by the calling function.
-    return strprintf("MnNetInfo()\n"
-                     "    %s\n",
-                     m_addr.ToString());
+    return IsEmpty() ? "MnNetInfo()"
+                     : strprintf("MnNetInfo(NetInfo(purpose=%s, [%s]))", PurposeToString(NetInfoPurpose::CORE_P2P),
+                                 m_addr.ToString());
+}
+
+bool ExtNetInfo::HasAddrPortDuplicates() const
+{
+    std::set<NetInfoEntry> known{};
+    for (const auto& entry : m_all_entries) {
+        if (auto [_, inserted] = known.insert(entry); !inserted) {
+            return true;
+        }
+    }
+    ASSERT_IF_DEBUG(known.size() == m_all_entries.size());
+    return false;
+}
+
+bool ExtNetInfo::IsAddrPortDuplicate(const NetInfoEntry& candidate) const
+{
+    return std::any_of(m_all_entries.begin(), m_all_entries.end(),
+                       [&candidate](const auto& entry) { return candidate == entry; });
+}
+
+bool ExtNetInfo::HasAddrDuplicates(const NetInfoList& entries) const
+{
+    std::unordered_set<std::string> known{};
+    for (const auto& entry : entries) {
+        if (auto [_, inserted] = known.insert(entry.ToStringAddr()); !inserted) {
+            return true;
+        }
+    }
+    ASSERT_IF_DEBUG(known.size() == entries.size());
+    return false;
+}
+
+bool ExtNetInfo::IsAddrDuplicate(const NetInfoEntry& candidate, const NetInfoList& entries) const
+{
+    const std::string& candidate_str{candidate.ToStringAddr()};
+    return std::any_of(entries.begin(), entries.end(),
+                       [&candidate_str](const auto& entry) { return candidate_str == entry.ToStringAddr(); });
+}
+
+NetInfoStatus ExtNetInfo::ProcessCandidate(const NetInfoPurpose purpose, const NetInfoEntry& candidate)
+{
+    assert(candidate.IsTriviallyValid());
+
+    if (IsAddrPortDuplicate(candidate)) {
+        return NetInfoStatus::Duplicate;
+    }
+    if (auto it{m_data.find(purpose)}; it != m_data.end()) {
+        // Existing entries list found, check limit
+        auto& [_, entries] = *it;
+        if (entries.size() >= MAX_ENTRIES_EXTNETINFO) {
+            return NetInfoStatus::MaxLimit;
+        }
+        if (IsAddrDuplicate(candidate, entries)) {
+            return NetInfoStatus::Duplicate;
+        }
+        entries.push_back(candidate);
+    } else {
+        // First entry for purpose code, create new entries list
+        auto [_, status] = m_data.try_emplace(purpose, std::vector<NetInfoEntry>({candidate}));
+        assert(status); // We did just check to see if our value already existed, try_emplace shouldn't fail
+    }
+
+    // Candidate succesfully added, update cache
+    m_all_entries.push_back(candidate);
+    return NetInfoStatus::Success;
+}
+
+NetInfoStatus ExtNetInfo::ValidateService(const CService& service)
+{
+    if (!service.IsValid()) {
+        return NetInfoStatus::BadAddress;
+    }
+    if (!service.IsIPv4() && !service.IsIPv6()) {
+        return NetInfoStatus::BadType;
+    }
+    if (Params().RequireRoutableExternalIP() && !service.IsRoutable()) {
+        return NetInfoStatus::NotRoutable;
+    }
+    if (IsBadPort(service.GetPort()) || service.GetPort() == 0) {
+        return NetInfoStatus::BadPort;
+    }
+
+    return NetInfoStatus::Success;
+}
+
+NetInfoStatus ExtNetInfo::AddEntry(const NetInfoPurpose purpose, const std::string& input)
+{
+    if (!IsValidPurpose(purpose)) {
+        return NetInfoStatus::MaxLimit;
+    }
+
+    // We don't allow assuming ports, so we set the default value to 0 so that if no port is specified
+    // it uses a fallback value of 0, which will return a NetInfoStatus::BadPort
+    std::string addr;
+    uint16_t port{0};
+    SplitHostPort(input, port, addr);
+    // Contains invalid characters, unlikely to pass Lookup(), fast-fail
+    if (!MatchCharsFilter(addr, SAFE_CHARS_IPV4_6)) {
+        return NetInfoStatus::BadInput;
+    }
+
+    if (auto service_opt{Lookup(addr, /*portDefault=*/port, /*fAllowLookup=*/false)}) {
+        const auto ret{ValidateService(*service_opt)};
+        if (ret == NetInfoStatus::Success) {
+            return ProcessCandidate(purpose, NetInfoEntry{*service_opt});
+        }
+        return ret; /* ValidateService() failed */
+    }
+    return NetInfoStatus::BadInput; /* Lookup() failed */
+}
+
+NetInfoList ExtNetInfo::GetEntries(std::optional<NetInfoPurpose> purpose_opt) const
+{
+    if (!purpose_opt) {
+        // Without a purpose code specified, we're being requested for a flattened list of all
+        // entries. ExtNetInfo is an append-only structure, so we can avoid re-calculating a
+        // list of all entries by maintaining a small cache.
+        return m_all_entries;
+    }
+    if (!IsValidPurpose(*purpose_opt)) return NetInfoList{};
+    const auto& it{m_data.find(*purpose_opt)};
+    return it != m_data.end() ? it->second : NetInfoList{};
+}
+
+CService ExtNetInfo::GetPrimary() const
+{
+    if (const auto& it{m_data.find(NetInfoPurpose::CORE_P2P)}; it != m_data.end()) {
+        const auto& [_, entries] = *it;
+        // If a purpose code is in the map, there should be at least one entry
+        ASSERT_IF_DEBUG(!entries.empty());
+        if (entries.size() >= 1) {
+            if (const auto& service_opt{entries[0].GetAddrPort()}) {
+                return *service_opt;
+            }
+        }
+    }
+    return CService{};
+}
+
+bool ExtNetInfo::HasEntries(NetInfoPurpose purpose) const
+{
+    if (!IsValidPurpose(purpose)) return false;
+    const auto& it{m_data.find(purpose)};
+    return it != m_data.end() && !it->second.empty();
+}
+
+NetInfoStatus ExtNetInfo::Validate() const
+{
+    if (m_version == 0 || m_version > CURRENT_VERSION || m_data.empty()) {
+        return NetInfoStatus::Malformed;
+    }
+    if (HasAddrPortDuplicates()) {
+        return NetInfoStatus::Duplicate;
+    }
+    for (const auto& [purpose, entries] : m_data) {
+        if (!IsValidPurpose(purpose)) {
+            return NetInfoStatus::Malformed;
+        }
+        if (entries.empty()) {
+            // Purpose if present in map must have at least one entry
+            return NetInfoStatus::Malformed;
+        }
+        if (HasAddrDuplicates(entries)) {
+            return NetInfoStatus::Duplicate;
+        }
+        for (const auto& entry : entries) {
+            if (!entry.IsTriviallyValid()) {
+                // Trivially invalid NetInfoEntry, no point checking against consensus rules
+                return NetInfoStatus::Malformed;
+            }
+            if (const auto& service_opt{entry.GetAddrPort()}) {
+                if (auto ret{ValidateService(*service_opt)}; ret != NetInfoStatus::Success) {
+                    // Stores CService underneath but doesn't pass validation rules
+                    return ret;
+                }
+            } else {
+                // Doesn't store valid type underneath
+                return NetInfoStatus::Malformed;
+            }
+        }
+    }
+    return NetInfoStatus::Success;
+}
+
+UniValue ExtNetInfo::ToJson(std::optional<NetInfoPurpose> purpose_opt) const
+{
+    // Report only a subset of all addresses if supplied a purpose code
+    if (purpose_opt) {
+        UniValue arr(UniValue::VARR);
+        for (const auto& entry : GetEntries(purpose_opt)) {
+            arr.push_back(entry.ToStringAddrPort());
+        }
+        return arr;
+    }
+
+    UniValue ret(UniValue::VOBJ);
+    for (const auto& [purpose, entries] : m_data) {
+        UniValue arr(UniValue::VARR);
+        for (const auto& entry : entries) {
+            arr.push_back(entry.ToStringAddrPort());
+        }
+        ret.pushKV(PurposeToString(purpose).data(), arr);
+    }
+    return ret;
+}
+
+std::string ExtNetInfo::ToString() const
+{
+    return IsEmpty() ? "ExtNetInfo()" : strprintf("ExtNetInfo(%s)", [&]() -> std::string {
+        std::string ret{};
+        bool first{true};
+        for (const auto& [purpose, entries] : m_data) {
+            if (!first) { ret += ", "; } else { first = false; }
+            ret += strprintf("NetInfo(purpose=%s, [%s])", PurposeToString(purpose), [&]() -> std::string {
+                if (entries.empty()) {
+                    return "invalid list";
+                }
+                return Join(entries, ", ", [](const auto& entry) { return entry.ToString(); });
+            }());
+        }
+        return ret;
+    }());
 }
diff --git a/src/evo/netinfo.h b/src/evo/netinfo.h
index 27f2ce932895..e261b2831e66 100644
--- a/src/evo/netinfo.h
+++ b/src/evo/netinfo.h
@@ -11,13 +11,18 @@
 
 #include <variant>
 
+class CChainParams;
 class CService;
 
 class UniValue;
 
+/** Maximum entries that can be stored in an ExtNetInfo per purpose code */
+static constexpr uint8_t MAX_ENTRIES_EXTNETINFO{4};
+
 enum class NetInfoStatus : uint8_t {
     // Managing entries
     BadInput,
+    Duplicate,
     MaxLimit,
 
     // Validation
@@ -41,6 +46,8 @@ constexpr std::string_view NISToString(const NetInfoStatus code)
         return "invalid port";
     case NetInfoStatus::BadType:
         return "invalid address type";
+    case NetInfoStatus::Duplicate:
+        return "duplicate";
     case NetInfoStatus::NotRoutable:
         return "unroutable address";
     case NetInfoStatus::Malformed:
@@ -53,9 +60,55 @@ constexpr std::string_view NISToString(const NetInfoStatus code)
     assert(false);
 }
 
-/* Identical to IsDeprecatedRPCEnabled("service"). For use outside of RPC code. */
+// A purpose corresponds to the index position in the ExtNetInfo map, entries must
+// be contiguous and cannot be changed once set without a format version update
+enum class NetInfoPurpose : uint8_t {
+    // Mandatory for masternodes
+    CORE_P2P = 0,
+    // Mandatory for EvoNodes
+    PLATFORM_P2P = 1,
+    PLATFORM_HTTPS = 2,
+};
+
+template<> struct is_serializable_enum<NetInfoPurpose> : std::true_type {};
+
+constexpr bool IsValidPurpose(const NetInfoPurpose purpose)
+{
+    switch (purpose) {
+    case NetInfoPurpose::CORE_P2P:
+    case NetInfoPurpose::PLATFORM_P2P:
+    case NetInfoPurpose::PLATFORM_HTTPS:
+        return true;
+    } // no default case, so the compiler can warn about missing cases
+    return false;
+}
+
+// Warning: Used in RPC code, altering existing values is a breaking change
+constexpr std::string_view PurposeToString(const NetInfoPurpose purpose)
+{
+    switch (purpose) {
+    case NetInfoPurpose::CORE_P2P:
+        return "core_p2p";
+    case NetInfoPurpose::PLATFORM_P2P:
+        return "platform_p2p";
+    case NetInfoPurpose::PLATFORM_HTTPS:
+        return "platform_https";
+    } // no default case, so the compiler can warn about missing cases
+    return "";
+}
+
+/** Will return true if node is running on mainnet */
+bool IsNodeOnMainnet();
+
+/** Identical to IsDeprecatedRPCEnabled("service"). For use outside of RPC code */
 bool IsServiceDeprecatedRPCEnabled();
 
+/** Creates a one-element array using CService::ToStringPortAddr() output */
+UniValue ArrFromService(const CService& addr);
+
+/** Equivalent to Params() if node is running on mainnet */
+const CChainParams& MainParams();
+
 class NetInfoEntry
 {
 public:
@@ -118,7 +171,7 @@ class NetInfoEntry
         m_data = std::monostate{};
     }
 
-    std::optional<std::reference_wrapper<const CService>> GetAddrPort() const;
+    std::optional<CService> GetAddrPort() const;
     uint16_t GetPort() const;
     bool IsEmpty() const { return *this == NetInfoEntry{}; }
     bool IsTriviallyValid() const;
@@ -129,7 +182,7 @@ class NetInfoEntry
 
 template<> struct is_serializable_enum<NetInfoEntry::NetInfoType> : std::true_type {};
 
-using NetInfoList = std::vector<std::reference_wrapper<const NetInfoEntry>>;
+using NetInfoList = std::vector<NetInfoEntry>;
 
 class NetInfoInterface
 {
@@ -139,14 +192,15 @@ class NetInfoInterface
 public:
     virtual ~NetInfoInterface() = default;
 
-    virtual NetInfoStatus AddEntry(const std::string& service) = 0;
-    virtual NetInfoList GetEntries() const = 0;
+    virtual NetInfoStatus AddEntry(const NetInfoPurpose purpose, const std::string& service) = 0;
+    virtual NetInfoList GetEntries(std::optional<NetInfoPurpose> purpose_opt = std::nullopt) const = 0;
 
-    virtual const CService& GetPrimary() const = 0;
+    virtual CService GetPrimary() const = 0;
     virtual bool CanStorePlatform() const = 0;
+    virtual bool HasEntries(NetInfoPurpose purpose) const = 0;
     virtual bool IsEmpty() const = 0;
     virtual NetInfoStatus Validate() const = 0;
-    virtual UniValue ToJson() const = 0;
+    virtual UniValue ToJson(std::optional<NetInfoPurpose> purpose_opt = std::nullopt) const = 0;
     virtual std::string ToString() const = 0;
 
     virtual void Clear() = 0;
@@ -176,8 +230,8 @@ class MnNetInfo final : public NetInfoInterface
     template <typename Stream>
     void Serialize(Stream& s) const
     {
-        if (const auto& service{m_addr.GetAddrPort()}; service.has_value()) {
-            s << service->get();
+        if (const auto service_opt{m_addr.GetAddrPort()}) {
+            s << *service_opt;
         } else {
             s << CService{};
         }
@@ -196,14 +250,15 @@ class MnNetInfo final : public NetInfoInterface
         m_addr = NetInfoEntry{service};
     }
 
-    NetInfoStatus AddEntry(const std::string& service) override;
-    NetInfoList GetEntries() const override;
+    NetInfoStatus AddEntry(const NetInfoPurpose purpose, const std::string& service) override;
+    NetInfoList GetEntries(std::optional<NetInfoPurpose> purpose_opt = std::nullopt) const override;
 
-    const CService& GetPrimary() const override;
+    CService GetPrimary() const override;
+    bool HasEntries(NetInfoPurpose purpose) const override { return purpose == NetInfoPurpose::CORE_P2P && !IsEmpty(); }
     bool IsEmpty() const override { return m_addr.IsEmpty(); }
     bool CanStorePlatform() const override { return false; }
     NetInfoStatus Validate() const override;
-    UniValue ToJson() const override;
+    UniValue ToJson(std::optional<NetInfoPurpose> purpose_opt = std::nullopt) const override;
     std::string ToString() const override;
 
     void Clear() override { m_addr.Clear(); }
@@ -219,6 +274,99 @@ class MnNetInfo final : public NetInfoInterface
     }
 };
 
+class ExtNetInfo final : public NetInfoInterface
+{
+private:
+    /** Update if serialization or ruleset changed */
+    static constexpr uint8_t CURRENT_VERSION{1};
+
+    /** Returns true if there are addr:port duplicates in the object */
+    bool HasAddrPortDuplicates() const;
+
+    /** Returns true if candidate is an addr:port duplicate in the object */
+    bool IsAddrPortDuplicate(const NetInfoEntry& candidate) const;
+
+    /** Returns true if there are addr duplicates within a given address list */
+    bool HasAddrDuplicates(const NetInfoList& entries) const;
+
+    /** Returns true if candidate is an addr duplicate within a given address list */
+    bool IsAddrDuplicate(const NetInfoEntry& candidate, const NetInfoList& entries) const;
+
+    /** Validate uniqueness requirements and add to object if passed */
+    NetInfoStatus ProcessCandidate(const NetInfoPurpose purpose, const NetInfoEntry& candidate);
+
+    /** Validate CService candidate address against ruleset */
+    static NetInfoStatus ValidateService(const CService& service);
+
+private:
+    uint8_t m_version{CURRENT_VERSION};
+    std::map<NetInfoPurpose, NetInfoList> m_data{};
+
+    // memory only
+    NetInfoList m_all_entries{};
+
+public:
+    ExtNetInfo() = default;
+    template <typename Stream>
+    ExtNetInfo(deserialize_type, Stream& s) { s >> *this; }
+
+    ~ExtNetInfo() = default;
+
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
+        s << m_version;
+        if (m_version == 0 || m_version > CURRENT_VERSION) {
+            return; // Don't bother with unknown versions
+        }
+        s << m_data;
+    }
+
+    template <typename Stream>
+    void Unserialize(Stream& s)
+    {
+        s >> m_version;
+        if (m_version == 0 || m_version > CURRENT_VERSION) {
+            return; // Don't bother with unknown versions
+        }
+        s >> m_data;
+
+        // Regenerate internal cache
+        m_all_entries.clear();
+        for (const auto& [_, entries] : m_data) {
+            m_all_entries.insert(m_all_entries.end(), entries.begin(), entries.end());
+        }
+    }
+
+    NetInfoStatus AddEntry(const NetInfoPurpose purpose, const std::string& input) override;
+    NetInfoList GetEntries(std::optional<NetInfoPurpose> purpose_opt = std::nullopt) const override;
+
+    CService GetPrimary() const override;
+    bool HasEntries(NetInfoPurpose purpose) const override;
+    bool IsEmpty() const override { return m_version == CURRENT_VERSION && m_data.empty(); }
+    bool CanStorePlatform() const override { return true; }
+    NetInfoStatus Validate() const override;
+    UniValue ToJson(std::optional<NetInfoPurpose> purpose_opt = std::nullopt) const override;
+    std::string ToString() const override;
+
+    void Clear() override
+    {
+        m_version = CURRENT_VERSION;
+        m_data.clear();
+        m_all_entries.clear();
+    }
+
+private:
+    // operator== and operator!= are defined by the parent which then leverage the child's IsEqual() override
+    // IsEqual() should only be called by NetInfoInterface::operator== otherwise static_cast assumption could fail
+    bool IsEqual(const NetInfoInterface& rhs) const override
+    {
+        ASSERT_IF_DEBUG(typeid(*this) == typeid(rhs));
+        const auto& rhs_obj{static_cast<const ExtNetInfo&>(rhs)};
+        return m_version == rhs_obj.m_version && m_data == rhs_obj.m_data;
+    }
+};
+
 class NetInfoSerWrapper
 {
 private:
@@ -232,8 +380,6 @@ class NetInfoSerWrapper
         m_data{data},
         m_is_extended{is_extended}
     {
-        // TODO: Remove when extended addresses implementation is added in
-        assert(!m_is_extended);
     }
 
     ~NetInfoSerWrapper() = default;
@@ -241,7 +387,9 @@ class NetInfoSerWrapper
     template <typename Stream>
     void Serialize(Stream& s) const
     {
-        if (const auto ptr{std::dynamic_pointer_cast<MnNetInfo>(m_data)}) {
+        if (const auto ptr{std::dynamic_pointer_cast<ExtNetInfo>(m_data)}) {
+            s << *ptr;
+        } else if (const auto ptr{std::dynamic_pointer_cast<MnNetInfo>(m_data)}) {
             s << *ptr;
         } else {
             // NetInfoInterface::MakeNetInfo() supplied an unexpected implementation or we didn't call it and
@@ -253,7 +401,11 @@ class NetInfoSerWrapper
     template <typename Stream>
     void Unserialize(Stream& s)
     {
-        m_data = std::make_shared<MnNetInfo>(deserialize, s);
+        if (m_is_extended) {
+            m_data = std::make_shared<ExtNetInfo>(deserialize, s);
+        } else {
+            m_data = std::make_shared<MnNetInfo>(deserialize, s);
+        }
     }
 };
 
diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp
index 02b749912143..6702ede99223 100644
--- a/src/evo/providertx.cpp
+++ b/src/evo/providertx.cpp
@@ -32,6 +32,30 @@ template uint16_t GetMaxFromDeployment<CProUpRegTx>(gsl::not_null<const CBlockIn
 template uint16_t GetMaxFromDeployment<CProUpRevTx>(gsl::not_null<const CBlockIndex*> pindexPrev, std::optional<bool> is_basic_override);
 } // namespace ProTxVersion
 
+template <typename ProTx>
+bool IsNetInfoTriviallyValid(const ProTx& proTx, TxValidationState& state)
+{
+    if (!proTx.netInfo->HasEntries(NetInfoPurpose::CORE_P2P)) {
+        // Mandatory for all nodes
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-empty");
+    }
+    if (proTx.nType == MnType::Regular) {
+        // Regular nodes shouldn't populate Platform-specific fields
+        if (proTx.netInfo->HasEntries(NetInfoPurpose::PLATFORM_HTTPS) ||
+            proTx.netInfo->HasEntries(NetInfoPurpose::PLATFORM_P2P)) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-bad");
+        }
+    }
+    if (proTx.netInfo->CanStorePlatform() && proTx.nType == MnType::Evo) {
+        // Platform fields are mandatory for EvoNodes
+        if (!proTx.netInfo->HasEntries(NetInfoPurpose::PLATFORM_HTTPS) ||
+            !proTx.netInfo->HasEntries(NetInfoPurpose::PLATFORM_P2P)) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-empty");
+        }
+    }
+    return true;
+}
+
 bool CProRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state) const
 {
     if (nVersion == 0 || nVersion > ProTxVersion::GetMaxFromDeployment<decltype(*this)>(pindexPrev)) {
@@ -59,7 +83,11 @@ bool CProRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, T
     if (netInfo->CanStorePlatform() != (nVersion == ProTxVersion::ExtAddr)) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-netinfo-version");
     }
-    for (const NetInfoEntry& entry : netInfo->GetEntries()) {
+    if (!netInfo->IsEmpty() && !IsNetInfoTriviallyValid(*this, state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+    for (const auto& entry : netInfo->GetEntries()) {
         if (!entry.IsTriviallyValid()) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-bad");
         }
@@ -115,14 +143,14 @@ std::string CProRegTx::ToString() const
         payee = EncodeDestination(dest);
     }
 
-    return strprintf("CProRegTx(nVersion=%d, nType=%d, collateralOutpoint=%s, nOperatorReward=%f, "
-                     "ownerAddress=%s, pubKeyOperator=%s, votingAddress=%s, scriptPayout=%s, platformNodeID=%s, "
-                     "platformP2PPort=%d, platformHTTPPort=%d)\n"
-                     "  %s",
-                     nVersion, ToUnderlying(nType), collateralOutpoint.ToStringShort(), (double)nOperatorReward / 100,
-                     EncodeDestination(PKHash(keyIDOwner)), pubKeyOperator.ToString(),
-                     EncodeDestination(PKHash(keyIDVoting)), payee, platformNodeID.ToString(), platformP2PPort,
-                     platformHTTPPort, netInfo->ToString());
+    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",
+                     nVersion, ToUnderlying(nType), collateralOutpoint.ToStringShort(), netInfo->ToString(),
+                     (double)nOperatorReward / 100, EncodeDestination(PKHash(keyIDOwner)), pubKeyOperator.ToString(),
+                     EncodeDestination(PKHash(keyIDVoting)), payee, platformNodeID.ToString(),
+                     (nVersion >= ProTxVersion::ExtAddr
+                          ? ""
+                          : strprintf(", platformP2PPort=%d, platformHTTPPort=%d", platformP2PPort, platformHTTPPort)));
 }
 
 bool CProUpServTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state) const
@@ -139,7 +167,11 @@ bool CProUpServTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev
     if (netInfo->IsEmpty()) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-empty");
     }
-    for (const NetInfoEntry& entry : netInfo->GetEntries()) {
+    if (!IsNetInfoTriviallyValid(*this, state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+    for (const auto& entry : netInfo->GetEntries()) {
         if (!entry.IsTriviallyValid()) {
             return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-bad");
         }
@@ -156,11 +188,13 @@ std::string CProUpServTx::ToString() const
         payee = EncodeDestination(dest);
     }
 
-    return strprintf("CProUpServTx(nVersion=%d, nType=%d, proTxHash=%s, operatorPayoutAddress=%s, "
-                     "platformNodeID=%s, platformP2PPort=%d, platformHTTPPort=%d)\n"
-                     "  %s",
-                     nVersion, ToUnderlying(nType), proTxHash.ToString(), payee, platformNodeID.ToString(),
-                     platformP2PPort, platformHTTPPort, netInfo->ToString());
+    return strprintf("CProUpServTx(nVersion=%d, nType=%d, proTxHash=%s, netInfo=%s, operatorPayoutAddress=%s, "
+                     "platformNodeID=%s%s)\n",
+                     nVersion, ToUnderlying(nType), proTxHash.ToString(), netInfo->ToString(), payee,
+                     platformNodeID.ToString(),
+                     (nVersion >= ProTxVersion::ExtAddr
+                          ? ""
+                          : strprintf(", platformP2PPort=%d, platformHTTPPort=%d", platformP2PPort, platformHTTPPort)));
 }
 
 bool CProUpRegTx::IsTriviallyValid(gsl::not_null<const CBlockIndex*> pindexPrev, TxValidationState& state) const
diff --git a/src/evo/providertx.h b/src/evo/providertx.h
index 9b756e20e997..f2173b20e086 100644
--- a/src/evo/providertx.h
+++ b/src/evo/providertx.h
@@ -102,9 +102,12 @@ class CProRegTx
         );
         if (obj.nType == MnType::Evo) {
             READWRITE(
-                obj.platformNodeID,
+                obj.platformNodeID);
+            if (obj.nVersion < ProTxVersion::ExtAddr) {
+                READWRITE(
                 obj.platformP2PPort,
                 obj.platformHTTPPort);
+            }
         }
         if (!(s.GetType() & SER_GETHASH)) {
             READWRITE(obj.vchSig);
@@ -161,9 +164,12 @@ class CProUpServTx
         );
         if (obj.nType == MnType::Evo) {
             READWRITE(
-                obj.platformNodeID,
+                obj.platformNodeID);
+            if (obj.nVersion < ProTxVersion::ExtAddr) {
+                READWRITE(
                 obj.platformP2PPort,
                 obj.platformHTTPPort);
+            }
         }
         if (!(s.GetType() & SER_GETHASH)) {
             READWRITE(
diff --git a/src/evo/simplifiedmns.cpp b/src/evo/simplifiedmns.cpp
index b84f2e98bf00..fcbc16d7587a 100644
--- a/src/evo/simplifiedmns.cpp
+++ b/src/evo/simplifiedmns.cpp
@@ -56,13 +56,13 @@ std::string CSimplifiedMNListEntry::ToString() const
         operatorPayoutAddress = EncodeDestination(dest);
     }
 
-    return strprintf("CSimplifiedMNListEntry(nVersion=%d, nType=%d, proRegTxHash=%s, confirmedHash=%s, "
+    return strprintf("CSimplifiedMNListEntry(nVersion=%d, nType=%d, proRegTxHash=%s, confirmedHash=%s, netInfo=%s, "
                      "pubKeyOperator=%s, votingAddress=%s, isValid=%d, payoutAddress=%s, operatorPayoutAddress=%s, "
-                     "platformHTTPPort=%d, platformNodeID=%s)\n"
-                     "  %s",
+                     "platformNodeID=%s%s)\n",
                      nVersion, ToUnderlying(nType), proRegTxHash.ToString(), confirmedHash.ToString(),
-                     pubKeyOperator.ToString(), EncodeDestination(PKHash(keyIDVoting)), isValid, payoutAddress,
-                     operatorPayoutAddress, platformHTTPPort, platformNodeID.ToString(), netInfo->ToString());
+                     netInfo->ToString(), pubKeyOperator.ToString(), EncodeDestination(PKHash(keyIDVoting)), isValid,
+                     payoutAddress, operatorPayoutAddress, platformNodeID.ToString(),
+                     (nVersion >= ProTxVersion::ExtAddr ? "" : strprintf(", platformHTTPPort=%d", platformHTTPPort)));
 }
 
 CSimplifiedMNList::CSimplifiedMNList(std::vector<std::unique_ptr<CSimplifiedMNListEntry>>&& smlEntries)
diff --git a/src/evo/simplifiedmns.h b/src/evo/simplifiedmns.h
index 7fef3623aa95..9153d0b025e1 100644
--- a/src/evo/simplifiedmns.h
+++ b/src/evo/simplifiedmns.h
@@ -65,7 +65,8 @@ class CSimplifiedMNListEntry
     SERIALIZE_METHODS(CSimplifiedMNListEntry, obj)
     {
         if ((s.GetType() & SER_NETWORK) && s.GetVersion() >= SMNLE_VERSIONED_PROTO_VERSION) {
-            READWRITE(obj.nVersion);
+            READWRITE(
+                obj.nVersion);
         }
         READWRITE(
                 obj.proRegTxHash,
@@ -74,16 +75,20 @@ class CSimplifiedMNListEntry
                                   obj.nVersion >= ProTxVersion::ExtAddr),
                 CBLSLazyPublicKeyVersionWrapper(const_cast<CBLSLazyPublicKey&>(obj.pubKeyOperator), (obj.nVersion == ProTxVersion::LegacyBLS)),
                 obj.keyIDVoting,
-                obj.isValid
-                );
+                obj.isValid);
         if ((s.GetType() & SER_NETWORK) && s.GetVersion() < DMN_TYPE_PROTO_VERSION) {
             return;
         }
         if (obj.nVersion >= ProTxVersion::BasicBLS) {
-            READWRITE(obj.nType);
+            READWRITE(
+                obj.nType);
             if (obj.nType == MnType::Evo) {
-                READWRITE(obj.platformHTTPPort);
-                READWRITE(obj.platformNodeID);
+                if (obj.nVersion < ProTxVersion::ExtAddr) {
+                READWRITE(
+                obj.platformHTTPPort);
+                }
+                READWRITE(
+                obj.platformNodeID);
             }
         }
     }
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index c049d13db048..9fcffe753299 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -257,10 +257,9 @@ bool CSpecialTxProcessor::BuildNewListFromBlock(const CBlock& block, gsl::not_nu
                 }
             }
 
-            for (const NetInfoEntry& entry : proTx.netInfo->GetEntries()) {
-                if (const auto& service_opt{entry.GetAddrPort()}; service_opt.has_value()) {
-                    const CService& service{service_opt.value()};
-                    if (newList.HasUniqueProperty(service)) {
+            for (const auto& entry : proTx.netInfo->GetEntries()) {
+                if (const auto service_opt{entry.GetAddrPort()}) {
+                    if (newList.HasUniqueProperty(*service_opt)) {
                         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-dup-netinfo-entry");
                     }
                 } else {
@@ -293,11 +292,10 @@ bool CSpecialTxProcessor::BuildNewListFromBlock(const CBlock& block, gsl::not_nu
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-payload");
             }
 
-            for (const NetInfoEntry& entry : opt_proTx->netInfo->GetEntries()) {
-                if (const auto& service_opt{entry.GetAddrPort()}; service_opt.has_value()) {
-                    const CService& service{service_opt.value()};
-                    if (newList.HasUniqueProperty(service) &&
-                        newList.GetUniquePropertyMN(service)->proTxHash != opt_proTx->proTxHash) {
+            for (const auto& entry : opt_proTx->netInfo->GetEntries()) {
+                if (const auto service_opt{entry.GetAddrPort()}) {
+                    if (newList.HasUniqueProperty(*service_opt) &&
+                        newList.GetUniquePropertyMN(*service_opt)->proTxHash != opt_proTx->proTxHash) {
                         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-protx-dup-netinfo-entry");
                     }
                 } else {
@@ -325,8 +323,10 @@ bool CSpecialTxProcessor::BuildNewListFromBlock(const CBlock& block, gsl::not_nu
             newState->scriptOperatorPayout = opt_proTx->scriptOperatorPayout;
             if (opt_proTx->nType == MnType::Evo) {
                 newState->platformNodeID = opt_proTx->platformNodeID;
-                newState->platformP2PPort = opt_proTx->platformP2PPort;
-                newState->platformHTTPPort = opt_proTx->platformHTTPPort;
+                if (opt_proTx->nVersion < ProTxVersion::ExtAddr) {
+                    newState->platformP2PPort = opt_proTx->platformP2PPort;
+                    newState->platformHTTPPort = opt_proTx->platformHTTPPort;
+                }
             }
             if (newState->IsBanned()) {
                 // only revive when all keys are set
diff --git a/src/rpc/coinjoin.cpp b/src/rpc/coinjoin.cpp
index c7d29f65204c..ca04c055dac0 100644
--- a/src/rpc/coinjoin.cpp
+++ b/src/rpc/coinjoin.cpp
@@ -434,12 +434,11 @@ static RPCHelpMan getcoinjoininfo()
                                     {RPCResult::Type::STR_HEX, "protxhash", "The ProTxHash of the masternode"},
                                     {RPCResult::Type::STR_HEX, "outpoint", "The outpoint of the masternode"},
                                     {RPCResult::Type::STR, "service", "The IP address and port of the masternode (DEPRECATED, returned only if config option -deprecatedrpc=service is passed)"},
-                                    {RPCResult::Type::ARR, "addresses", "Network addresses of the masternode",
-                                    {
+                                    {RPCResult::Type::ARR, "addrs_core_p2p", "Network addresses of the masternode used for protocol P2P",
                                         {
                                             {RPCResult::Type::STR, "address", ""},
                                         }
-                                    }},
+                                    },
                                     {RPCResult::Type::NUM, "denomination", "The denomination of the mixing session in " + CURRENCY_UNIT + ""},
                                     {RPCResult::Type::STR_HEX, "state", "Current state of the mixing session"},
                                     {RPCResult::Type::NUM, "entries_count", "The number of entries in the mixing session"},
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 02e2fb68de23..cc7052b453c3 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -183,13 +183,37 @@ static RPCArg GetRpcArg(const std::string& strParamName)
             {"platformNodeID", RPCArg::Type::STR, RPCArg::Optional::NO,
                 "Platform P2P node ID, derived from P2P public key."}
         },
-        {"platformP2PPort",
-            {"platformP2PPort", RPCArg::Type::NUM, RPCArg::Optional::NO,
-                "TCP port of Dash Platform peer-to-peer communication between nodes (network byte order)."}
+        {"platformP2PAddrs",
+            {"platformP2PAddrs", RPCArg::Type::ARR, RPCArg::Optional::NO,
+                "Array of addresses in the form \"ADDR:PORT\" used by Platform for peer-to-peer connection.\n"
+                "Must be unique on the network. Can be set to an empty string, which will require a ProUpServTx afterwards.",
+                {
+                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, ""},
+                }}
+        },
+        {"platformP2PAddrs_update",
+            {"platformP2PAddrs", RPCArg::Type::ARR, RPCArg::Optional::NO,
+                "Array of addresses in the form \"ADDR:PORT\" used by Platform for peer-to-peer connection.\n"
+                "Must be unique on the network.",
+                {
+                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, ""},
+                }}
         },
-        {"platformHTTPPort",
-            {"platformHTTPPort", RPCArg::Type::NUM, RPCArg::Optional::NO,
-                "TCP port of Platform HTTP/API interface (network byte order)."}
+        {"platformHTTPSAddrs",
+            {"platformHTTPSAddrs", RPCArg::Type::ARR, RPCArg::Optional::NO,
+                "Array of addresses in the form \"ADDR:PORT\" used by Platform for their HTTPS API.\n"
+                "Must be unique on the network. Can be set to an empty string, which will require a ProUpServTx afterwards.",
+                {
+                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, ""},
+                }}
+        },
+        {"platformHTTPSAddrs_update",
+            {"platformHTTPSAddrs", RPCArg::Type::ARR, RPCArg::Optional::NO,
+                "Array of addresses in the form \"ADDR:PORT\" used by Platform for their HTTPS API.\n"
+                "Must be unique on the network.",
+                {
+                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, ""},
+                }}
         },
     };
 
@@ -551,8 +575,8 @@ static RPCHelpMan protx_register_fund_evo()
             GetRpcArg("operatorReward"),
             GetRpcArg("payoutAddress_register"),
             GetRpcArg("platformNodeID"),
-            GetRpcArg("platformP2PPort"),
-            GetRpcArg("platformHTTPPort"),
+            GetRpcArg("platformP2PAddrs"),
+            GetRpcArg("platformHTTPSAddrs"),
             GetRpcArg("fundAddress"),
             GetRpcArg("submit"),
         },
@@ -590,8 +614,8 @@ static RPCHelpMan protx_register_evo()
             GetRpcArg("operatorReward"),
             GetRpcArg("payoutAddress_register"),
             GetRpcArg("platformNodeID"),
-            GetRpcArg("platformP2PPort"),
-            GetRpcArg("platformHTTPPort"),
+            GetRpcArg("platformP2PAddrs"),
+            GetRpcArg("platformHTTPSAddrs"),
             GetRpcArg("feeSourceAddress"),
             GetRpcArg("submit"),
         },
@@ -628,8 +652,8 @@ static RPCHelpMan protx_register_prepare_evo()
             GetRpcArg("operatorReward"),
             GetRpcArg("payoutAddress_register"),
             GetRpcArg("platformNodeID"),
-            GetRpcArg("platformP2PPort"),
-            GetRpcArg("platformHTTPPort"),
+            GetRpcArg("platformP2PAddrs"),
+            GetRpcArg("platformHTTPSAddrs"),
             GetRpcArg("feeSourceAddress"),
         },
         RPCResult{
@@ -734,7 +758,7 @@ static UniValue protx_register_common_wrapper(const JSONRPCRequest& request,
         }
         ptx.platformNodeID.SetHex(request.params[paramIdx + 6].get_str());
 
-        ProcessNetInfoPlatform(ptx, request.params[paramIdx + 7], request.params[paramIdx + 8]);
+        ProcessNetInfoPlatform(ptx, request.params[paramIdx + 7], request.params[paramIdx + 8], /*optional=*/true);
 
         paramIdx += 3;
     }
@@ -942,8 +966,8 @@ static RPCHelpMan protx_update_service_evo()
             GetRpcArg("coreP2PAddrs_update"),
             GetRpcArg("operatorKey"),
             GetRpcArg("platformNodeID"),
-            GetRpcArg("platformP2PPort"),
-            GetRpcArg("platformHTTPPort"),
+            GetRpcArg("platformP2PAddrs_update"),
+            GetRpcArg("platformHTTPSAddrs_update"),
             GetRpcArg("operatorPayoutAddress"),
             GetRpcArg("feeSourceAddress"),
             GetRpcArg("submit"),
@@ -1004,7 +1028,7 @@ static UniValue protx_update_service_common_wrapper(const JSONRPCRequest& reques
         }
         ptx.platformNodeID.SetHex(request.params[paramIdx].get_str());
 
-        ProcessNetInfoPlatform(ptx, request.params[paramIdx + 1], request.params[paramIdx + 2]);
+        ProcessNetInfoPlatform(ptx, request.params[paramIdx + 1], request.params[paramIdx + 2], /*optional=*/false);
 
         paramIdx += 3;
     }
diff --git a/src/rpc/evo_util.cpp b/src/rpc/evo_util.cpp
index a054beacb6b3..927bd55439fb 100644
--- a/src/rpc/evo_util.cpp
+++ b/src/rpc/evo_util.cpp
@@ -4,85 +4,135 @@
 
 #include <rpc/evo_util.h>
 
-#include <evo/netinfo.h>
 #include <evo/providertx.h>
 #include <rpc/protocol.h>
 #include <rpc/request.h>
-#include <rpc/util.h>
-#include <util/check.h>
 
 #include <univalue.h>
 
-template <typename T1>
-void ProcessNetInfoCore(T1& ptx, const UniValue& input, const bool optional)
-{
-    CHECK_NONFATAL(ptx.netInfo);
+namespace {
+bool IsNumeric(std::string_view input) { return input.find_first_not_of("0123456789") == std::string::npos; }
 
-    if (input.isStr()) {
-        const std::string& entry = input.get_str();
-        if (entry.empty()) {
-            if (!optional) {
-                throw JSONRPCError(RPC_INVALID_PARAMETER, "Empty param for coreP2PAddrs not allowed");
-            }
-            return; // Nothing to do
-        }
-        if (auto entryRet = ptx.netInfo->AddEntry(entry); entryRet != NetInfoStatus::Success) {
+template <typename ProTx>
+void ParseInput(ProTx& ptx, std::string_view field_name, const std::string& input_str, NetInfoPurpose purpose,
+                size_t idx, bool optional)
+{
+    if (input_str.empty()) {
+        if (!optional) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
-                               strprintf("Error setting coreP2PAddrs[0] to '%s' (%s)", entry, NISToString(entryRet)));
+                               strprintf("Invalid param for %s[%zu], cannot be empty", field_name, idx));
         }
-        return; // Parsing complete
+        return; // Nothing to do
+    }
+    if (auto ret = ptx.netInfo->AddEntry(purpose, input_str); ret != NetInfoStatus::Success) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER,
+                           strprintf("Error setting %s[%zu] to '%s' (%s)", field_name, idx, input_str, NISToString(ret)));
     }
+}
+} // anonymous namespace
+
+template <typename ProTx>
+void ProcessNetInfoCore(ProTx& ptx, const UniValue& input, const bool optional)
+{
+    CHECK_NONFATAL(ptx.netInfo);
 
-    if (input.isArray()) {
+    if (input.isStr()) {
+        ParseInput(ptx, /*field_name=*/"coreP2PAddrs", input.get_str(), NetInfoPurpose::CORE_P2P, /*idx=*/0, optional);
+    } else if (input.isArray()) {
         const UniValue& entries = input.get_array();
-        if (entries.empty()) {
-            if (!optional) {
-                throw JSONRPCError(RPC_INVALID_PARAMETER, "Empty params for coreP2PAddrs not allowed");
-            }
-            return; // Nothing to do
+        if (!optional && entries.empty()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid param for coreP2PAddrs, cannot be empty");
         }
         for (size_t idx{0}; idx < entries.size(); idx++) {
             const UniValue& entry_uv{entries[idx]};
             if (!entry_uv.isStr()) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
-                                   strprintf("Invalid param for coreP2PAddrs[%d], must be string", idx));
-            }
-            const std::string& entry = entry_uv.get_str();
-            if (entry.empty()) {
-                throw JSONRPCError(RPC_INVALID_PARAMETER,
-                                   strprintf("Invalid param for coreP2PAddrs[%d], cannot be empty string", idx));
-            }
-            if (auto entryRet = ptx.netInfo->AddEntry(entry); entryRet != NetInfoStatus::Success) {
-                throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Error setting coreP2PAddrs[%d] to '%s' (%s)", idx,
-                                                                    entry, NISToString(entryRet)));
+                                   strprintf("Invalid param for coreP2PAddrs[%zu], must be string", idx));
             }
+            ParseInput(ptx, /*field_name=*/"coreP2PAddrs", entry_uv.get_str(), NetInfoPurpose::CORE_P2P, idx,
+                       /*optional=*/false);
         }
-        return; // Parsing complete
+    } else {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid param for coreP2PAddrs, must be string or array");
     }
-
-    // Invalid input
-    throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid param for coreP2PAddrs, must be string or array");
 }
 template void ProcessNetInfoCore(CProRegTx& ptx, const UniValue& input, const bool optional);
 template void ProcessNetInfoCore(CProUpServTx& ptx, const UniValue& input, const bool optional);
 
-template <typename T1>
-void ProcessNetInfoPlatform(T1& ptx, const UniValue& input_p2p, const UniValue& input_http)
+template <typename ProTx>
+void ProcessNetInfoPlatform(ProTx& ptx, const UniValue& input_p2p, const UniValue& input_http, const bool optional)
 {
     CHECK_NONFATAL(ptx.netInfo);
 
-    auto process_field = [](uint16_t& target, const UniValue& input, const std::string& field_name) {
-        if (!input.isNum() && !input.isStr()) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid param for %s, must be number", field_name));
+    auto process_field = [&](uint16_t& maybe_target, const UniValue& input, const NetInfoPurpose purpose,
+                             std::string_view field_name) {
+        if (!input.isArray() && !input.isNum() && !input.isStr()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER,
+                               strprintf("Invalid param for %s, must be array, number or string", field_name));
         }
-        if (int32_t port{ParseInt32V(input, field_name)}; port >= 1 && port <= std::numeric_limits<uint16_t>::max()) {
-            target = static_cast<uint16_t>(port);
+
+        bool is_empty{input.isArray() ? input.get_array().empty() : input.getValStr().empty()};
+        bool is_nonnumeric_str{input.isStr() && !IsNumeric(input.getValStr())};
+        if (is_empty || is_nonnumeric_str || input.isArray()) {
+            if (is_empty) {
+                if (!optional) {
+                    // Mandatory field, cannot specify blank value
+                    throw JSONRPCError(RPC_INVALID_PARAMETER,
+                                       strprintf("Invalid param for %s, cannot be empty", field_name));
+                }
+                if (!ptx.netInfo->IsEmpty()) {
+                    // Blank values are tolerable so long as no other field has been populated.
+                    throw JSONRPCError(RPC_INVALID_PARAMETER,
+                                       strprintf("Invalid param for %s, cannot be empty if other fields populated",
+                                                 field_name));
+                }
+            }
+            if (!ptx.netInfo->CanStorePlatform()) {
+                //      Arrays: Expected to be address strings, if relying on platform{HTTP,P2P}Port, bail out.
+                // Empty Input: We can tolerate blank values if netInfo can store platform fields, if it cannot, we are relying
+                //              on platform{HTTP,P2P}Port, where it is mandatory even if their netInfo counterpart is optional.
+                //      String: If not parsable as port and relying on platform{HTTP,P2P}Port, bail out.
+                throw JSONRPCError(RPC_INVALID_PARAMETER,
+                                   strprintf("Invalid param for %s, ProTx version only supports ports", field_name));
+            }
+            if (input.isArray()) {
+                const UniValue& entries = input.get_array();
+                for (size_t idx{0}; idx < entries.size(); idx++) {
+                    const UniValue& entry{entries[idx]};
+                    if (!entry.isStr() || IsNumeric(entry.get_str())) {
+                        throw JSONRPCError(RPC_INVALID_PARAMETER,
+                                           strprintf("Invalid param for %s[%zu], must be string", field_name, idx));
+                    }
+                    ParseInput(ptx, field_name, entry.get_str(), purpose, idx, /*optional=*/false);
+                }
+            } else {
+                CHECK_NONFATAL(is_empty || is_nonnumeric_str);
+                ParseInput(ptx, field_name, input.get_str(), purpose, /*idx=*/0, /*optional=*/true);
+            }
         } else {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("%s must be a valid port [1-65535]", field_name));
+            if (int32_t port{0};
+                ParseInt32(input.getValStr(), &port) && port >= 1 && port <= std::numeric_limits<uint16_t>::max()) {
+                // Valid port
+                if (!ptx.netInfo->CanStorePlatform()) {
+                    maybe_target = static_cast<uint16_t>(port);
+                    return; // Parsing complete
+                }
+                // We cannot store *only* a port number in netInfo so we need to associate it with the primary service of CORE_P2P manually
+                if (!ptx.netInfo->HasEntries(NetInfoPurpose::CORE_P2P)) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER,
+                                       strprintf("Cannot set param for %s, must specify coreP2PAddrs first", field_name));
+                }
+                const CService service{CNetAddr{ptx.netInfo->GetPrimary()}, static_cast<uint16_t>(port)};
+                CHECK_NONFATAL(service.IsValid());
+                ParseInput(ptx, field_name, service.ToStringAddrPort(), purpose, /*idx=*/0, /*optional=*/false);
+            } else {
+                throw JSONRPCError(RPC_INVALID_PARAMETER,
+                                   strprintf("Invalid param for %s, must be a valid port [1-65535]", field_name));
+            }
         }
     };
-    process_field(ptx.platformP2PPort, input_p2p, "platformP2PPort");
-    process_field(ptx.platformHTTPPort, input_http, "platformHTTPPort");
+    process_field(ptx.platformP2PPort, input_p2p, NetInfoPurpose::PLATFORM_P2P, "platformP2PAddrs");
+    process_field(ptx.platformHTTPPort, input_http, NetInfoPurpose::PLATFORM_HTTPS, "platformHTTPSAddrs");
 }
-template void ProcessNetInfoPlatform(CProRegTx& ptx, const UniValue& input_p2p, const UniValue& input_http);
-template void ProcessNetInfoPlatform(CProUpServTx& ptx, const UniValue& input_p2p, const UniValue& input_http);
+template void ProcessNetInfoPlatform(CProRegTx& ptx, const UniValue& input_p2p, const UniValue& input_http, const bool optional);
+template void ProcessNetInfoPlatform(CProUpServTx& ptx, const UniValue& input_p2p, const UniValue& input_http, const bool optional);
diff --git a/src/rpc/evo_util.h b/src/rpc/evo_util.h
index de06acc36028..6734558e43bb 100644
--- a/src/rpc/evo_util.h
+++ b/src/rpc/evo_util.h
@@ -5,12 +5,84 @@
 #ifndef BITCOIN_RPC_EVO_UTIL_H
 #define BITCOIN_RPC_EVO_UTIL_H
 
-class UniValue;
+#include <netaddress.h>
+#include <util/check.h>
 
-template <typename T1>
-void ProcessNetInfoCore(T1& ptx, const UniValue& input, const bool optional);
+#include <evo/dmn_types.h>
+#include <evo/netinfo.h>
 
-template <typename T1>
-void ProcessNetInfoPlatform(T1& ptx, const UniValue& input_p2p, const UniValue& input_http);
+#include <cstdint>
+#include <type_traits>
+
+#include <univalue.h>
+
+class CSimplifiedMNListEntry;
+
+/** Process setting (legacy) Core network information field based on ProTx version */
+template <typename ProTx>
+void ProcessNetInfoCore(ProTx& ptx, const UniValue& input, const bool optional);
+
+/** Process setting (legacy) Platform network information fields based on ProTx version */
+template <typename ProTx>
+void ProcessNetInfoPlatform(ProTx& ptx, const UniValue& input_p2p, const UniValue& input_http, const bool optional);
+
+/** Reads network info reporting and appends data from legacy fields if applicable */
+template <typename Obj>
+UniValue GetNetInfoWithLegacyFields(const Obj& obj, const MnType& type)
+{
+    UniValue ret{CHECK_NONFATAL(obj.netInfo)->ToJson()};
+
+    // Nothing to do here if not EvoNode, netInfo is empty or netInfo is capable of natively
+    // storing Platform fields
+    if (type != MnType::Evo || obj.netInfo->IsEmpty() || obj.netInfo->CanStorePlatform()) return ret;
+
+    CNetAddr addr{obj.netInfo->GetPrimary()};
+    ret.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_HTTPS).data(),
+               ArrFromService(CService(addr, obj.platformHTTPPort)));
+
+    if constexpr (!std::is_same_v<std::decay_t<Obj>, CSimplifiedMNListEntry>) {
+        // CSimplifiedMNListEntry doesn't store platformP2PPort
+        ret.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_P2P).data(),
+                   ArrFromService(CService(addr, obj.platformP2PPort)));
+    }
+
+    return ret;
+}
+
+/** Returns platform port based on purpose and network info version */
+template <bool is_p2p, typename Obj>
+int32_t GetPlatformPort(const Obj& obj)
+{
+    // Currently, there is nothing that prevents PLATFORM_{HTTPS,P2P} to be registered to
+    // an addr *different* from the primary addr for CORE_P2P. This breaks the assumptions
+    // under which platform{HTTP,P2P}Port operate under (i.e. all three are hosted with the
+    // same addr).
+    //
+    // TODO: Introduce restrictions that enforce this assumption *until* we remove legacy
+    //       fields for good.
+    //
+    bool is_legacy{!(CHECK_NONFATAL(obj.netInfo)->CanStorePlatform())};
+    if constexpr (is_p2p) {
+        static_assert(!std::is_same_v<std::decay_t<Obj>, CSimplifiedMNListEntry>,
+                      "CSimplifiedMNListEntry doesn't have platformP2PPort");
+        if (is_legacy) {
+            return obj.platformP2PPort;
+        }
+        if (obj.netInfo->IsEmpty()) {
+            return -1; // Blank entry, nothing to report
+        }
+        CHECK_NONFATAL(obj.netInfo->HasEntries(NetInfoPurpose::PLATFORM_P2P));
+        return obj.netInfo->GetEntries(NetInfoPurpose::PLATFORM_P2P)[0].GetPort();
+    } else {
+        if (is_legacy) {
+            return obj.platformHTTPPort;
+        }
+        if (obj.netInfo->IsEmpty()) {
+            return -1; // Blank entry, nothing to report
+        }
+        CHECK_NONFATAL(obj.netInfo->HasEntries(NetInfoPurpose::PLATFORM_HTTPS));
+        return obj.netInfo->GetEntries(NetInfoPurpose::PLATFORM_HTTPS)[0].GetPort();
+    }
+}
 
 #endif // BITCOIN_RPC_EVO_UTIL_H
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index 7f354a5ecc2b..2ee79cff82e9 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -6,14 +6,15 @@
 #include <evo/assetlocktx.h>
 #include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
-#include <index/txindex.h>
-#include <node/blockstorage.h>
-#include <node/context.h>
 #include <governance/governance.h>
+#include <index/txindex.h>
 #include <masternode/node.h>
 #include <masternode/payments.h>
 #include <net.h>
 #include <netbase.h>
+#include <node/blockstorage.h>
+#include <node/context.h>
+#include <rpc/evo_util.h>
 #include <rpc/server.h>
 #include <rpc/server_util.h>
 #include <rpc/util.h>
@@ -566,7 +567,7 @@ static RPCHelpMan masternodelist_helper(bool is_composite)
         std::string strAddress{};
         if (strMode == "addr" || strMode == "full" || strMode == "info" || strMode == "json" || strMode == "recent" ||
             strMode == "evo") {
-            for (const NetInfoEntry& entry : dmn.pdmnState->netInfo->GetEntries()) {
+            for (const auto& entry : dmn.pdmnState->netInfo->GetEntries()) {
                 strAddress += entry.ToStringAddrPort() + " ";
             }
             if (!strAddress.empty()) strAddress.pop_back(); // Remove trailing space
@@ -616,14 +617,14 @@ static RPCHelpMan masternodelist_helper(bool is_composite)
             if (IsDeprecatedRPCEnabled("service")) {
                 objMN.pushKV("address", dmn.pdmnState->netInfo->GetPrimary().ToStringAddrPort());
             }
-            objMN.pushKV("addresses", dmn.pdmnState->netInfo->ToJson());
+            objMN.pushKV("addresses", GetNetInfoWithLegacyFields(*dmn.pdmnState, dmn.nType));
             objMN.pushKV("payee", payeeStr);
             objMN.pushKV("status", dmnToStatus(dmn));
             objMN.pushKV("type", std::string(GetMnType(dmn.nType).description));
             if (dmn.nType == MnType::Evo) {
                 objMN.pushKV("platformNodeID", dmn.pdmnState->platformNodeID.ToString());
-                objMN.pushKV("platformP2PPort", dmn.pdmnState->platformP2PPort);
-                objMN.pushKV("platformHTTPPort", dmn.pdmnState->platformHTTPPort);
+                objMN.pushKV("platformP2PPort", GetPlatformPort</*is_p2p=*/true>(*dmn.pdmnState));
+                objMN.pushKV("platformHTTPPort", GetPlatformPort</*is_p2p=*/false>(*dmn.pdmnState));
             }
             objMN.pushKV("pospenaltyscore", dmn.pdmnState->nPoSePenalty);
             objMN.pushKV("consecutivePayments", dmn.pdmnState->nConsecutivePayments);
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index c25cb717dfb2..9834874cc0ac 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -7,6 +7,7 @@
 #include <index/txindex.h>
 #include <net_processing.h>
 #include <node/context.h>
+#include <rpc/evo_util.h>
 #include <rpc/server.h>
 #include <rpc/server_util.h>
 #include <rpc/util.h>
@@ -207,7 +208,7 @@ static UniValue BuildQuorumInfo(const llmq::CQuorumBlockProcessor& quorum_block_
             if (IsDeprecatedRPCEnabled("service")) {
                 mo.pushKV("service", dmn->pdmnState->netInfo->GetPrimary().ToStringAddrPort());
             }
-            mo.pushKV("addresses", dmn->pdmnState->netInfo->ToJson());
+            mo.pushKV("addresses", GetNetInfoWithLegacyFields(*dmn->pdmnState, dmn->nType));
             mo.pushKV("pubKeyOperator", dmn->pdmnState->pubKeyOperator.ToString());
             mo.pushKV("valid", static_cast<bool>(quorum->qc->validMembers[i]));
             if (quorum->qc->validMembers[i]) {
diff --git a/src/test/block_reward_reallocation_tests.cpp b/src/test/block_reward_reallocation_tests.cpp
index 9b60fd89a69e..ffb7ced72a22 100644
--- a/src/test/block_reward_reallocation_tests.cpp
+++ b/src/test/block_reward_reallocation_tests.cpp
@@ -118,7 +118,8 @@ static CMutableTransaction CreateProRegTx(const CChain& active_chain, const CTxM
     proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
     proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
     proTx.collateralOutpoint.n = 0;
-    BOOST_CHECK_EQUAL(proTx.netInfo->AddEntry(strprintf("1.1.1.1:%d", port)), NetInfoStatus::Success);
+    BOOST_CHECK_EQUAL(proTx.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, strprintf("1.1.1.1:%d", port)),
+                      NetInfoStatus::Success);
     proTx.keyIDOwner = ownerKeyRet.GetPubKey().GetID();
     proTx.pubKeyOperator.Set(operatorKeyRet.GetPublicKey(), bls::bls_legacy_scheme.load());
     proTx.keyIDVoting = ownerKeyRet.GetPubKey().GetID();
diff --git a/src/test/evo_deterministicmns_tests.cpp b/src/test/evo_deterministicmns_tests.cpp
index c58f32116de3..c67d4dd40725 100644
--- a/src/test/evo_deterministicmns_tests.cpp
+++ b/src/test/evo_deterministicmns_tests.cpp
@@ -108,7 +108,8 @@ static CMutableTransaction CreateProRegTx(const CChain& active_chain, const CTxM
     proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
     proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
     proTx.collateralOutpoint.n = 0;
-    BOOST_CHECK_EQUAL(proTx.netInfo->AddEntry(strprintf("1.1.1.1:%d", port)), NetInfoStatus::Success);
+    BOOST_CHECK_EQUAL(proTx.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, strprintf("1.1.1.1:%d", port)),
+                      NetInfoStatus::Success);
     proTx.keyIDOwner = ownerKeyRet.GetPubKey().GetID();
     proTx.pubKeyOperator.Set(operatorKeyRet.GetPublicKey(), bls::bls_legacy_scheme.load());
     proTx.keyIDVoting = ownerKeyRet.GetPubKey().GetID();
@@ -131,7 +132,8 @@ static CMutableTransaction CreateProUpServTx(const CChain& active_chain, const C
     proTx.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
     proTx.netInfo = NetInfoInterface::MakeNetInfo(proTx.nVersion);
     proTx.proTxHash = proTxHash;
-    BOOST_CHECK_EQUAL(proTx.netInfo->AddEntry(strprintf("1.1.1.1:%d", port)), NetInfoStatus::Success);
+    BOOST_CHECK_EQUAL(proTx.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, strprintf("1.1.1.1:%d", port)),
+                      NetInfoStatus::Success);
     proTx.scriptOperatorPayout = scriptOperatorPayout;
 
     CMutableTransaction tx;
@@ -645,7 +647,7 @@ void FuncTestMempoolReorg(TestChainSetup& setup)
     CProRegTx payload;
     payload.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
     payload.netInfo = NetInfoInterface::MakeNetInfo(payload.nVersion);
-    BOOST_CHECK_EQUAL(payload.netInfo->AddEntry("1.1.1.1:1"), NetInfoStatus::Success);
+    BOOST_CHECK_EQUAL(payload.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:1"), NetInfoStatus::Success);
     payload.keyIDOwner = ownerKey.GetPubKey().GetID();
     payload.pubKeyOperator.Set(operatorKey.GetPublicKey(), bls::bls_legacy_scheme.load());
     payload.keyIDVoting = ownerKey.GetPubKey().GetID();
@@ -721,7 +723,7 @@ void FuncTestMempoolDualProregtx(TestChainSetup& setup)
     CProRegTx payload;
     payload.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
     payload.netInfo = NetInfoInterface::MakeNetInfo(payload.nVersion);
-    BOOST_CHECK_EQUAL(payload.netInfo->AddEntry("1.1.1.1:2"), NetInfoStatus::Success);
+    BOOST_CHECK_EQUAL(payload.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:2"), NetInfoStatus::Success);
     payload.keyIDOwner = ownerKey.GetPubKey().GetID();
     payload.pubKeyOperator.Set(operatorKey.GetPublicKey(), bls::bls_legacy_scheme.load());
     payload.keyIDVoting = ownerKey.GetPubKey().GetID();
@@ -791,7 +793,7 @@ void FuncVerifyDB(TestChainSetup& setup)
     CProRegTx payload;
     payload.nVersion = ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false);
     payload.netInfo = NetInfoInterface::MakeNetInfo(payload.nVersion);
-    BOOST_CHECK_EQUAL(payload.netInfo->AddEntry("1.1.1.1:1"), NetInfoStatus::Success);
+    BOOST_CHECK_EQUAL(payload.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:1"), NetInfoStatus::Success);
     payload.keyIDOwner = ownerKey.GetPubKey().GetID();
     payload.pubKeyOperator.Set(operatorKey.GetPublicKey(), bls::bls_legacy_scheme.load());
     payload.keyIDVoting = ownerKey.GetPubKey().GetID();
@@ -855,7 +857,7 @@ static CDeterministicMNCPtr create_mock_mn(uint64_t internal_id)
     dmnState->keyIDVoting = ownerKey.GetPubKey().GetID();
     dmnState->netInfo = NetInfoInterface::MakeNetInfo(
         ProTxVersion::GetMax(!bls::bls_legacy_scheme, /*is_extended_addr=*/false));
-    BOOST_CHECK_EQUAL(dmnState->netInfo->AddEntry("1.1.1.1:1"), NetInfoStatus::Success);
+    BOOST_CHECK_EQUAL(dmnState->netInfo->AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:1"), NetInfoStatus::Success);
 
     auto dmn = std::make_shared<CDeterministicMN>(internal_id, MnType::Regular);
     dmn->proTxHash = GetRandHash();
diff --git a/src/test/evo_netinfo_tests.cpp b/src/test/evo_netinfo_tests.cpp
index 50138f5c0818..7c20deebf4e9 100644
--- a/src/test/evo_netinfo_tests.cpp
+++ b/src/test/evo_netinfo_tests.cpp
@@ -15,27 +15,41 @@
 
 BOOST_FIXTURE_TEST_SUITE(evo_netinfo_tests, BasicTestingSetup)
 
-const std::vector<std::pair</*input=*/std::string, /*expected_ret=*/NetInfoStatus>> vals{
+struct TestEntry {
+    std::pair</*purpose=*/NetInfoPurpose, /*addr=*/std::string> input;
+    NetInfoStatus expected_ret_mn;
+    NetInfoStatus expected_ret_ext;
+};
+
+static const std::vector<TestEntry> vals_main{
     // Address and port specified
-    {"1.1.1.1:9999", NetInfoStatus::Success},
-    // Address specified, port should default to default P2P core
-    {"1.1.1.1", NetInfoStatus::Success},
-    // Non-mainnet port on mainnet
-    {"1.1.1.1:9998", NetInfoStatus::BadPort},
+    {{NetInfoPurpose::CORE_P2P, "1.1.1.1:9999"}, NetInfoStatus::Success, NetInfoStatus::Success},
+    // - Port should default to default P2P core with MnNetInfo
+    // - Ports are no longer implied with ExtNetInfo
+    {{NetInfoPurpose::CORE_P2P, "1.1.1.1"}, NetInfoStatus::Success, NetInfoStatus::BadPort},
+    // - Non-mainnet port on mainnet causes failure in MnNetInfo
+    // - ExtNetInfo is indifferent to choice of port unless it's a bad port which 9998 isn't
+    {{NetInfoPurpose::CORE_P2P, "1.1.1.1:9998"}, NetInfoStatus::BadPort, NetInfoStatus::Success},
     // Internal addresses not allowed on mainnet
-    {"127.0.0.1:9999", NetInfoStatus::NotRoutable},
+    {{NetInfoPurpose::CORE_P2P, "127.0.0.1:9999"}, NetInfoStatus::NotRoutable, NetInfoStatus::NotRoutable},
     // Valid IPv4 formatting but invalid IPv4 address
-    {"0.0.0.0:9999", NetInfoStatus::BadAddress},
+    {{NetInfoPurpose::CORE_P2P, "0.0.0.0:9999"}, NetInfoStatus::BadAddress, NetInfoStatus::BadAddress},
     // Port greater than uint16_t max
-    {"1.1.1.1:99999", NetInfoStatus::BadInput},
-    // Only IPv4 allowed
-    {"[2606:4700:4700::1111]:9999", NetInfoStatus::BadInput},
+    {{NetInfoPurpose::CORE_P2P, "1.1.1.1:99999"}, NetInfoStatus::BadInput, NetInfoStatus::BadInput},
+    // - Non-IPv4 addresses are prohibited in MnNetInfo
+    // - Any valid BIP155 address is allowed in ExtNetInfo
+    {{NetInfoPurpose::CORE_P2P, "[2606:4700:4700::1111]:9999"}, NetInfoStatus::BadInput, NetInfoStatus::Success},
     // Domains are not allowed
-    {"example.com:9999", NetInfoStatus::BadInput},
+    {{NetInfoPurpose::CORE_P2P, "example.com:9999"}, NetInfoStatus::BadInput, NetInfoStatus::BadInput},
     // Incorrect IPv4 address
-    {"1.1.1.256:9999", NetInfoStatus::BadInput},
+    {{NetInfoPurpose::CORE_P2P, "1.1.1.256:9999"}, NetInfoStatus::BadInput, NetInfoStatus::BadInput},
     // Missing address
-    {":9999", NetInfoStatus::BadInput},
+    {{NetInfoPurpose::CORE_P2P, ":9999"}, NetInfoStatus::BadInput, NetInfoStatus::BadInput},
+    // Bad purpose code
+    {{static_cast<NetInfoPurpose>(64), "1.1.1.1:9999"}, NetInfoStatus::MaxLimit, NetInfoStatus::MaxLimit},
+    // - MnNetInfo doesn't allow storing anything except a Core P2P address
+    // - ExtNetInfo allows storing Platform P2P addresses
+    {{NetInfoPurpose::PLATFORM_P2P, "1.1.1.1:9999"}, NetInfoStatus::MaxLimit, NetInfoStatus::Success},
 };
 
 void ValidateGetEntries(const NetInfoList& entries, const size_t expected_size)
@@ -46,29 +60,127 @@ void ValidateGetEntries(const NetInfoList& entries, const size_t expected_size)
     }
 }
 
-BOOST_AUTO_TEST_CASE(mnnetinfo_rules)
+void TestMnNetInfo(const std::vector<TestEntry>& vals)
 {
-    // Validate AddEntry() rules enforcement
-    for (const auto& [input, expected_ret] : vals) {
+    for (const auto& [input, expected_ret, _] : vals) {
+        const auto& [purpose, addr] = input;
         MnNetInfo netInfo;
-        BOOST_CHECK_EQUAL(netInfo.AddEntry(input), expected_ret);
+        BOOST_CHECK_EQUAL(netInfo.AddEntry(purpose, addr), expected_ret);
         if (expected_ret != NetInfoStatus::Success) {
             // An empty MnNetInfo is considered malformed
             BOOST_CHECK_EQUAL(netInfo.Validate(), NetInfoStatus::Malformed);
+            BOOST_CHECK(!netInfo.HasEntries(purpose));
+            BOOST_CHECK(netInfo.GetEntries().empty());
+        } else {
+            BOOST_CHECK_EQUAL(netInfo.Validate(), NetInfoStatus::Success);
+            BOOST_CHECK(netInfo.HasEntries(purpose));
+            ValidateGetEntries(netInfo.GetEntries(), /*expected_size=*/1);
+        }
+    }
+}
+
+void TestExtNetInfo(const std::vector<TestEntry>& vals)
+{
+    for (const auto& [input, _, expected_ret] : vals) {
+        const auto& [purpose, addr] = input;
+        ExtNetInfo netInfo;
+        BOOST_CHECK_EQUAL(netInfo.AddEntry(purpose, addr), expected_ret);
+        if (expected_ret != NetInfoStatus::Success) {
+            // An empty ExtNetInfo is considered malformed
+            BOOST_CHECK_EQUAL(netInfo.Validate(), NetInfoStatus::Malformed);
+            BOOST_CHECK(!netInfo.HasEntries(purpose));
             BOOST_CHECK(netInfo.GetEntries().empty());
         } else {
             BOOST_CHECK_EQUAL(netInfo.Validate(), NetInfoStatus::Success);
+            BOOST_CHECK(netInfo.HasEntries(purpose));
             ValidateGetEntries(netInfo.GetEntries(), /*expected_size=*/1);
         }
     }
+}
+
+BOOST_AUTO_TEST_CASE(mnnetinfo_rules_main)
+{
+    TestMnNetInfo(vals_main);
 
     {
         // MnNetInfo only stores one value, overwriting prohibited
         MnNetInfo netInfo;
-        BOOST_CHECK_EQUAL(netInfo.AddEntry("1.1.1.1:9999"), NetInfoStatus::Success);
-        BOOST_CHECK_EQUAL(netInfo.AddEntry("1.1.1.2:9999"), NetInfoStatus::MaxLimit);
+        BOOST_CHECK_EQUAL(netInfo.AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:9999"), NetInfoStatus::Success);
+        BOOST_CHECK_EQUAL(netInfo.AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.2:9999"), NetInfoStatus::MaxLimit);
+        BOOST_CHECK(netInfo.HasEntries(NetInfoPurpose::CORE_P2P));
         ValidateGetEntries(netInfo.GetEntries(), /*expected_size=*/1);
     }
+
+    {
+        // MnNetInfo only allows storing a Core P2P address
+        MnNetInfo netInfo;
+        for (const auto purpose : {NetInfoPurpose::PLATFORM_HTTPS, NetInfoPurpose::PLATFORM_P2P}) {
+            BOOST_CHECK_EQUAL(netInfo.AddEntry(purpose, "1.1.1.1:9999"), NetInfoStatus::MaxLimit);
+            BOOST_CHECK(!netInfo.HasEntries(purpose));
+        }
+        BOOST_CHECK(netInfo.GetEntries().empty());
+    }
+}
+
+BOOST_AUTO_TEST_CASE(extnetinfo_rules_main) { TestExtNetInfo(vals_main); }
+
+static const std::vector<TestEntry> vals_reg{
+    // - MnNetInfo doesn't mind using port 0
+    // - ExtNetInfo requires non-zero ports
+    {{NetInfoPurpose::CORE_P2P, "1.1.1.1:0"}, NetInfoStatus::Success, NetInfoStatus::BadPort},
+    // - Mainnet P2P port on non-mainnet cause failure in MnNetInfo
+    // - ExtNetInfo is indifferent to choice of port unless it's a bad port which 9999 isn't
+    {{NetInfoPurpose::CORE_P2P, "1.1.1.1:9999"}, NetInfoStatus::BadPort, NetInfoStatus::Success},
+    // - Non-mainnet P2P port is allowed in MnNetInfo regardless of bad port status
+    // - Port 22 (SSH) is below the privileged ports threshold (1023) and is therefore a bad port, disallowed in ExtNetInfo
+    {{NetInfoPurpose::CORE_P2P, "1.1.1.1:22"}, NetInfoStatus::Success, NetInfoStatus::BadPort},
+};
+
+BOOST_FIXTURE_TEST_CASE(mnnetinfo_rules_reg, RegTestingSetup) { TestMnNetInfo(vals_reg); }
+
+BOOST_FIXTURE_TEST_CASE(extnetinfo_rules_reg, RegTestingSetup)
+{
+    TestExtNetInfo(vals_reg);
+
+    {
+        // ExtNetInfo can store up to 4 entries per purpose code, check limit enforcement
+        ExtNetInfo netInfo;
+        for (size_t idx{1}; idx <= MAX_ENTRIES_EXTNETINFO; idx++) {
+            BOOST_CHECK_EQUAL(netInfo.AddEntry(NetInfoPurpose::CORE_P2P, strprintf("1.1.1.%d:9998", idx)),
+                              NetInfoStatus::Success);
+        }
+        BOOST_CHECK_EQUAL(netInfo.AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.5:9998"), NetInfoStatus::MaxLimit);
+        BOOST_CHECK(netInfo.HasEntries(NetInfoPurpose::CORE_P2P));
+        // The limit applies *per purpose code* and therefore wouldn't error if the address was for a different purpose
+        BOOST_CHECK(!netInfo.HasEntries(NetInfoPurpose::PLATFORM_P2P));
+        BOOST_CHECK_EQUAL(netInfo.AddEntry(NetInfoPurpose::PLATFORM_P2P, "1.1.1.5:9998"), NetInfoStatus::Success);
+        BOOST_CHECK(netInfo.HasEntries(NetInfoPurpose::PLATFORM_P2P));
+        BOOST_CHECK_EQUAL(netInfo.Validate(), NetInfoStatus::Success);
+        // GetEntries() is a tally of all entries across all purpose codes
+        ValidateGetEntries(netInfo.GetEntries(), /*expected_size=*/MAX_ENTRIES_EXTNETINFO + 1);
+    }
+
+    {
+        // ExtNetInfo has restrictions on duplicates
+        ExtNetInfo netInfo;
+        BOOST_CHECK_EQUAL(netInfo.AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:9998"), NetInfoStatus::Success);
+
+        // Exact (i.e. addr:port) duplicates are prohibited *within* a list
+        BOOST_CHECK_EQUAL(netInfo.AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:9998"), NetInfoStatus::Duplicate);
+        // Partial (i.e. different port) duplicates are prohibited *within* a list
+        BOOST_CHECK_EQUAL(netInfo.AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:9997"), NetInfoStatus::Duplicate);
+
+        // Exact (i.e. addr:port) duplicates are prohibited *across* lists
+        BOOST_CHECK_EQUAL(netInfo.AddEntry(NetInfoPurpose::PLATFORM_P2P, "1.1.1.1:9998"), NetInfoStatus::Duplicate);
+        // Partial (i.e. different port) duplicates are allowed *across* a list
+        BOOST_CHECK_EQUAL(netInfo.AddEntry(NetInfoPurpose::PLATFORM_P2P, "1.1.1.1:9997"), NetInfoStatus::Success);
+
+        BOOST_CHECK_EQUAL(netInfo.Validate(), NetInfoStatus::Success);
+        BOOST_CHECK(netInfo.HasEntries(NetInfoPurpose::CORE_P2P));
+        BOOST_CHECK(netInfo.HasEntries(NetInfoPurpose::PLATFORM_P2P));
+        BOOST_CHECK(!netInfo.HasEntries(NetInfoPurpose::PLATFORM_HTTPS));
+        ValidateGetEntries(netInfo.GetEntries(), /*expected_size=*/2);
+    }
 }
 
 BOOST_AUTO_TEST_CASE(netinfo_ser)
@@ -193,31 +305,31 @@ BOOST_AUTO_TEST_CASE(cservice_compatible)
     // Valid IPv4 address, valid port
     service = LookupNumeric("1.1.1.1", 9999);
     netInfo.Clear();
-    BOOST_CHECK_EQUAL(netInfo.AddEntry("1.1.1.1:9999"), NetInfoStatus::Success);
+    BOOST_CHECK_EQUAL(netInfo.AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:9999"), NetInfoStatus::Success);
     BOOST_CHECK(CheckIfSerSame(service, netInfo));
 
     // Valid IPv4 address, default P2P port implied
     service = LookupNumeric("1.1.1.1", Params().GetDefaultPort());
     netInfo.Clear();
-    BOOST_CHECK_EQUAL(netInfo.AddEntry("1.1.1.1"), NetInfoStatus::Success);
+    BOOST_CHECK_EQUAL(netInfo.AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1"), NetInfoStatus::Success);
     BOOST_CHECK(CheckIfSerSame(service, netInfo));
 
     // Lookup() failure (domains not allowed), MnNetInfo should remain empty if Lookup() failed
     service = CService();
     netInfo.Clear();
-    BOOST_CHECK_EQUAL(netInfo.AddEntry("example.com"), NetInfoStatus::BadInput);
+    BOOST_CHECK_EQUAL(netInfo.AddEntry(NetInfoPurpose::CORE_P2P, "example.com"), NetInfoStatus::BadInput);
     BOOST_CHECK(CheckIfSerSame(service, netInfo));
 
     // Validation failure (non-IPv4 not allowed), MnNetInfo should remain empty if ValidateService() failed
     service = CService();
     netInfo.Clear();
-    BOOST_CHECK_EQUAL(netInfo.AddEntry("[2606:4700:4700::1111]:9999"), NetInfoStatus::BadInput);
+    BOOST_CHECK_EQUAL(netInfo.AddEntry(NetInfoPurpose::CORE_P2P, "[2606:4700:4700::1111]:9999"), NetInfoStatus::BadInput);
     BOOST_CHECK(CheckIfSerSame(service, netInfo));
 }
 
 BOOST_AUTO_TEST_CASE(interface_equality)
 {
-    // We also check for symmetry as NetInfoInterface, MnNetInfo and NetInfoEntry
+    // We also check for symmetry as NetInfoInterface, ExtNetInfo, MnNetInfo and NetInfoEntry
     // define their operator!= as the inverse of operator==
     std::shared_ptr<NetInfoInterface> ptr_lhs{nullptr}, ptr_rhs{nullptr};
 
@@ -234,7 +346,21 @@ BOOST_AUTO_TEST_CASE(interface_equality)
     BOOST_CHECK(util::shared_ptr_equal(ptr_lhs, ptr_rhs) && !util::shared_ptr_not_equal(ptr_lhs, ptr_rhs));
 
     // Equal initialization state, same type, differing values
-    BOOST_CHECK_EQUAL(ptr_rhs->AddEntry("1.1.1.1:9999"), NetInfoStatus::Success);
+    BOOST_CHECK_EQUAL(ptr_rhs->AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:9999"), NetInfoStatus::Success);
+    BOOST_CHECK(!util::shared_ptr_equal(ptr_lhs, ptr_rhs) && util::shared_ptr_not_equal(ptr_lhs, ptr_rhs));
+
+    // Equal initialization state, different type, same values
+    ptr_rhs = std::make_shared<ExtNetInfo>();
+    BOOST_CHECK(ptr_lhs->IsEmpty() && ptr_rhs->IsEmpty());
+    BOOST_CHECK(!util::shared_ptr_equal(ptr_lhs, ptr_rhs) && util::shared_ptr_not_equal(ptr_lhs, ptr_rhs));
+
+    // Equal initialization state, same type, same values
+    ptr_lhs = std::make_shared<ExtNetInfo>();
+    BOOST_CHECK(ptr_lhs->IsEmpty() && ptr_rhs->IsEmpty());
+    BOOST_CHECK(util::shared_ptr_equal(ptr_lhs, ptr_rhs) && !util::shared_ptr_not_equal(ptr_lhs, ptr_rhs));
+
+    // Equal initialization state, same type, differing values
+    BOOST_CHECK_EQUAL(ptr_rhs->AddEntry(NetInfoPurpose::CORE_P2P, "1.1.1.1:9999"), NetInfoStatus::Success);
     BOOST_CHECK(!util::shared_ptr_equal(ptr_lhs, ptr_rhs) && util::shared_ptr_not_equal(ptr_lhs, ptr_rhs));
 }
 
diff --git a/src/test/evo_simplifiedmns_tests.cpp b/src/test/evo_simplifiedmns_tests.cpp
index 02fef713c0e2..a3ea64683452 100644
--- a/src/test/evo_simplifiedmns_tests.cpp
+++ b/src/test/evo_simplifiedmns_tests.cpp
@@ -24,7 +24,8 @@ BOOST_AUTO_TEST_CASE(simplifiedmns_merkleroots)
         smle.proRegTxHash.SetHex(strprintf("%064x", i));
         smle.confirmedHash.SetHex(strprintf("%064x", i));
 
-        BOOST_CHECK_EQUAL(smle.netInfo->AddEntry(strprintf("%d.%d.%d.%d:%d", 0, 0, 0, i, i)), NetInfoStatus::Success);
+        BOOST_CHECK_EQUAL(smle.netInfo->AddEntry(NetInfoPurpose::CORE_P2P, strprintf("%d.%d.%d.%d:%d", 0, 0, 0, i, i)),
+                          NetInfoStatus::Success);
 
         std::vector<unsigned char> vecBytes{static_cast<unsigned char>(i)};
         vecBytes.resize(CBLSSecretKey::SerSize);
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 32f91fc65c06..e8324f5a6572 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -651,7 +651,7 @@ void CTxMemPool::addUncheckedProTx(indexed_transaction_set::iterator& newit, con
         if (!proTx.collateralOutpoint.hash.IsNull()) {
             mapProTxRefs.emplace(tx_hash, proTx.collateralOutpoint.hash);
         }
-        for (const NetInfoEntry& entry : proTx.netInfo->GetEntries()) {
+        for (const auto& entry : proTx.netInfo->GetEntries()) {
             mapProTxAddresses.emplace(entry, tx_hash);
         }
         mapProTxPubKeyIDs.emplace(proTx.keyIDOwner, tx_hash);
@@ -664,7 +664,7 @@ void CTxMemPool::addUncheckedProTx(indexed_transaction_set::iterator& newit, con
     } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SERVICE) {
         auto proTx = *Assert(GetTxPayload<CProUpServTx>(tx));
         mapProTxRefs.emplace(proTx.proTxHash, tx_hash);
-        for (const NetInfoEntry& entry : proTx.netInfo->GetEntries()) {
+        for (const auto& entry : proTx.netInfo->GetEntries()) {
             mapProTxAddresses.emplace(entry, tx_hash);
         }
     } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_REGISTRAR) {
@@ -755,7 +755,7 @@ void CTxMemPool::removeUncheckedProTx(const CTransaction& tx)
         if (!proTx.collateralOutpoint.IsNull()) {
             eraseProTxRef(tx_hash, proTx.collateralOutpoint.hash);
         }
-        for (const NetInfoEntry& entry : proTx.netInfo->GetEntries()) {
+        for (const auto& entry : proTx.netInfo->GetEntries()) {
             mapProTxAddresses.erase(entry);
         }
         mapProTxPubKeyIDs.erase(proTx.keyIDOwner);
@@ -765,7 +765,7 @@ void CTxMemPool::removeUncheckedProTx(const CTransaction& tx)
     } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_SERVICE) {
         auto proTx = *Assert(GetTxPayload<CProUpServTx>(tx));
         eraseProTxRef(proTx.proTxHash, tx_hash);
-        for (const NetInfoEntry& entry : proTx.netInfo->GetEntries()) {
+        for (const auto& entry : proTx.netInfo->GetEntries()) {
             mapProTxAddresses.erase(entry);
         }
     } else if (tx.nType == TRANSACTION_PROVIDER_UPDATE_REGISTRAR) {
@@ -994,7 +994,7 @@ void CTxMemPool::removeProTxConflicts(const CTransaction &tx)
         }
         auto& proTx = *opt_proTx;
 
-        for (const NetInfoEntry& entry : proTx.netInfo->GetEntries()) {
+        for (const auto& entry : proTx.netInfo->GetEntries()) {
             if (mapProTxAddresses.count(entry)) {
                 uint256 conflictHash = mapProTxAddresses[entry];
                 if (conflictHash != tx_hash && mapTx.count(conflictHash)) {
@@ -1016,7 +1016,7 @@ void CTxMemPool::removeProTxConflicts(const CTransaction &tx)
             return;
         }
 
-        for (const NetInfoEntry& entry : opt_proTx->netInfo->GetEntries()) {
+        for (const auto& entry : opt_proTx->netInfo->GetEntries()) {
             if (mapProTxAddresses.count(entry)) {
                 uint256 conflictHash = mapProTxAddresses[entry];
                 if (conflictHash != tx_hash && mapTx.count(conflictHash)) {
@@ -1354,7 +1354,7 @@ bool CTxMemPool::existsProviderTxConflict(const CTransaction &tx) const {
             return true; // i.e. can't decode payload == conflict
         }
         auto& proTx = *opt_proTx;
-        for (const NetInfoEntry& entry : proTx.netInfo->GetEntries()) {
+        for (const auto& entry : proTx.netInfo->GetEntries()) {
             if (mapProTxAddresses.count(entry)) {
                 return true;
             }
@@ -1379,7 +1379,7 @@ bool CTxMemPool::existsProviderTxConflict(const CTransaction &tx) const {
             LogPrint(BCLog::MEMPOOL, "%s: ERROR: Invalid transaction payload, tx: %s\n", __func__, tx_hash.ToString());
             return true; // i.e. can't decode payload == conflict
         }
-        for (const NetInfoEntry& entry : opt_proTx->netInfo->GetEntries()) {
+        for (const auto& entry : opt_proTx->netInfo->GetEntries()) {
             auto it = mapProTxAddresses.find(entry);
             if (it != mapProTxAddresses.end() && it->second != opt_proTx->proTxHash) {
                 return true;
diff --git a/test/functional/feature_dip3_deterministicmns.py b/test/functional/feature_dip3_deterministicmns.py
index 7494f6536d1e..ac73dd5af055 100755
--- a/test/functional/feature_dip3_deterministicmns.py
+++ b/test/functional/feature_dip3_deterministicmns.py
@@ -272,13 +272,13 @@ def update_mn_payee(self, mn: MasternodeInfo, payee):
 
     def test_protx_update_service(self, mn: MasternodeInfo):
         self.nodes[0].sendtoaddress(mn.fundsAddr, 0.001)
-        mn.update_service(self.nodes[0], submit=True, coreP2PAddrs=[f'127.0.0.2:{mn.nodePort}'])
+        mn.update_service(self.nodes[0], submit=True, addrs_core_p2p=[f'127.0.0.2:{mn.nodePort}'])
         self.generate(self.nodes[0], 1)
         for node in self.nodes:
             protx_info = node.protx('info', mn.proTxHash)
             mn_list = node.masternode('list')
-            assert_equal(protx_info['state']['addresses'][0], '127.0.0.2:%d' % mn.nodePort)
-            assert_equal(mn_list['%s-%d' % (mn.collateral_txid, mn.collateral_vout)]['addresses'][0], '127.0.0.2:%d' % mn.nodePort)
+            assert_equal(protx_info['state']['addresses']['core_p2p'][0], '127.0.0.2:%d' % mn.nodePort)
+            assert_equal(mn_list['%s-%d' % (mn.collateral_txid, mn.collateral_vout)]['addresses']['core_p2p'][0], '127.0.0.2:%d' % mn.nodePort)
 
         # undo
         mn.update_service(self.nodes[0], submit=True)
diff --git a/test/functional/rpc_netinfo.py b/test/functional/rpc_netinfo.py
index ba1951b820d7..e2972e18f824 100755
--- a/test/functional/rpc_netinfo.py
+++ b/test/functional/rpc_netinfo.py
@@ -5,7 +5,8 @@
 """Test network information fields across RPCs."""
 
 from test_framework.util import (
-    assert_equal
+    assert_equal,
+    softfork_active
 )
 from test_framework.script import (
     hash160
@@ -19,20 +20,28 @@
 
 from _decimal import Decimal
 from random import randint
+from typing import List, Optional
 
+# Height at which BIP9 deployment DEPLOYMENT_V23 is activated
+V23_ACTIVATION_THRESHOLD = 100
 # See CMainParams in src/chainparams.cpp
 DEFAULT_PORT_MAINNET_CORE_P2P = 9999
 # See CRegTestParams in src/chainparams.cpp
 DEFAULT_PORT_PLATFORM_P2P = 22200
 DEFAULT_PORT_PLATFORM_HTTP = 22201
+# See CDeterministicMNStateDiff::ToJson() in src/evo/dmnstate.h
+DMNSTATE_DIFF_DUMMY_ADDR = "255.255.255.255"
+# See ProTxVersion in src/evo/providertx.h
+PROTXVER_BASIC = 2
+PROTXVER_EXTADDR = 3
 
-class Node:
+class EvoNode:
     mn: MasternodeInfo
     node: TestNode
     platform_nodeid: str = ""
 
-    def __init__(self, node: TestNode, is_evo: bool):
-        self.mn = MasternodeInfo(evo=is_evo, legacy=False)
+    def __init__(self, node: TestNode):
+        self.mn = MasternodeInfo(evo=True, legacy=False)
         self.mn.generate_addresses(node)
         self.mn.set_node(node.index)
         self.mn.set_params(nodePort=p2p_port(node.index))
@@ -40,11 +49,11 @@ def __init__(self, node: TestNode, is_evo: bool):
 
     def generate_collateral(self, test: BitcoinTestFramework):
         assert self.mn.nodeIdx is not None
-
+        # Generate enough blocks to cover collateral amount
         while self.node.getbalance() < self.mn.get_collateral_value():
             test.bump_mocktime(1)
             test.generate(self.node, 10, sync_fun=test.no_op)
-
+        # Create collateral UTXO
         collateral_txid = self.node.sendmany("", {self.mn.collateral_address: self.mn.get_collateral_value(), self.mn.fundsAddr: 1})
         self.mn.bury_tx(test, self.mn.nodeIdx, collateral_txid, 1)
         collateral_vout = self.mn.get_collateral_vout(self.node, collateral_txid)
@@ -57,68 +66,54 @@ def is_mn_visible(self, _protx_hash = None) -> bool:
         for mn_entry in mn_list:
             dmn = mn_list.get(mn_entry)
             if dmn['proTxHash'] == protx_hash:
-                assert_equal(dmn['type'], "Evo" if self.mn.evo else "Regular")
+                assert_equal(dmn['type'], "Evo")
                 mn_visible = True
         return mn_visible
 
-    def register_mn(self, test: BitcoinTestFramework, submit: bool, addrs_core_p2p, addrs_platform_p2p = None, addrs_platform_http = None, code = None, msg = None) -> str:
-        assert self.mn.nodeIdx is not None
+    def set_active_state(self, test: BitcoinTestFramework, active: bool, more_extra_args: Optional[List[str]] = None):
+        assert self.mn.proTxHash and self.mn.keyOperator
+        target_extra_args = self.node.extra_args.copy()
+        if active:
+            target_extra_args += [f'-masternodeblsprivkey={self.mn.keyOperator}']
+        if more_extra_args is not None:
+            target_extra_args += more_extra_args
+        test.restart_node(self.mn.nodeIdx, extra_args=target_extra_args)
 
-        if self.mn.evo and (not addrs_platform_http or not addrs_platform_p2p):
-            raise AssertionError("EvoNode but platformP2PPort and platformHTTPPort not specified")
-
-        # Evonode-specific fields are ignored if regular masternode
+    def register_mn(self, test: BitcoinTestFramework, submit: bool, addrs_core_p2p, addrs_platform_p2p, addrs_platform_https, code = None, msg = None) -> Optional[str]:
+        assert self.mn.nodeIdx is not None
         self.platform_nodeid = hash160(b'%d' % randint(1, 65535)).hex()
-        protx_output = self.mn.register(self.node, submit=submit, coreP2PAddrs=addrs_core_p2p, operator_reward=0,
-                                        platform_node_id=self.platform_nodeid, platform_p2p_port=addrs_platform_p2p,
-                                        platform_http_port=addrs_platform_http, expected_assert_code=code, expected_assert_msg=msg)
-
-        # If we expected error, make sure the transaction didn't succeed
-        if code and msg:
-            assert protx_output is None
-            return ""
-        else:
-            assert protx_output is not None
-            if not submit:
-                return ""
-
+        protx_output = self.mn.register(self.node, submit=submit, addrs_core_p2p=addrs_core_p2p, operator_reward=0,
+                                        platform_node_id=self.platform_nodeid, addrs_platform_p2p=addrs_platform_p2p,
+                                        addrs_platform_https=addrs_platform_https, expected_assert_code=code, expected_assert_msg=msg)
+        if (code and msg) or not submit:
+            return protx_output
+        assert protx_output is not None
         # Bury ProTx transaction and check if masternode is online
         self.mn.set_params(proTxHash=protx_output, operator_reward=0)
         self.mn.bury_tx(test, self.mn.nodeIdx, protx_output, 1)
         assert_equal(self.is_mn_visible(), True)
-
-        test.log.debug(f"Registered {'Evo' if self.mn.evo else 'regular'} masternode with collateral_txid={self.mn.collateral_txid}, "
-                       f"collateral_vout={self.mn.collateral_vout}, provider_txid={self.mn.proTxHash}")
-
-        test.restart_node(self.mn.nodeIdx, extra_args=self.node.extra_args + [f'-masternodeblsprivkey={self.mn.keyOperator}'])
+        test.log.debug(f"Registered EvoNode with collateral_txid={self.mn.collateral_txid}, collateral_vout={self.mn.collateral_vout}, provider_txid={self.mn.proTxHash}")
         return self.mn.proTxHash
 
-    def update_mn(self, test: BitcoinTestFramework, addrs_core_p2p, addrs_platform_p2p = None, addrs_platform_http = None) -> str:
+    def update_mn(self, test: BitcoinTestFramework, submit: bool, addrs_core_p2p, addrs_platform_p2p, addrs_platform_https, code = None, msg = None) -> Optional[str]:
         assert self.mn.nodeIdx is not None
-
-        if self.mn.evo and (not addrs_platform_http or not addrs_platform_p2p):
-            raise AssertionError("EvoNode but platformP2PPort and platformHTTPPort not specified")
-
-        # Evonode-specific fields are ignored if regular masternode
-        protx_output = self.mn.update_service(self.node, submit=True, coreP2PAddrs=addrs_core_p2p, platform_node_id=self.platform_nodeid,
-                                              platform_p2p_port=addrs_platform_p2p, platform_http_port=addrs_platform_http)
+        protx_output = self.mn.update_service(self.node, submit=submit, addrs_core_p2p=addrs_core_p2p, platform_node_id=self.platform_nodeid,
+                                              addrs_platform_p2p=addrs_platform_p2p, addrs_platform_https=addrs_platform_https,
+                                              expected_assert_code=code, expected_assert_msg=msg)
+        if (code and msg) or not submit:
+            return protx_output
         assert protx_output is not None
-
         self.mn.bury_tx(test, self.mn.nodeIdx, protx_output, 1)
         assert_equal(self.is_mn_visible(), True)
-
-        test.log.debug(f"Updated {'Evo' if self.mn.evo else 'regular'} masternode with collateral_txid={self.mn.collateral_txid}, "
-                       f"collateral_vout={self.mn.collateral_vout}, provider_txid={self.mn.proTxHash}")
+        test.log.debug(f"Updated EvoNode with collateral_txid={self.mn.collateral_txid}, collateral_vout={self.mn.collateral_vout}, provider_txid={self.mn.proTxHash}")
         return protx_output
 
     def destroy_mn(self, test: BitcoinTestFramework):
         assert self.mn.nodeIdx is not None
-
         # Get UTXO from address used to pay fees, generate new addresses
         address_funds_unspent = self.node.listunspent(0, 99999, [self.mn.fundsAddr])[0]
         address_funds_value = address_funds_unspent['amount']
         self.mn.generate_addresses(self.node, True)
-
         # Create transaction to spend old collateral and fee change
         raw_tx = self.node.createrawtransaction([
                 { 'txid': self.mn.collateral_txid, 'vout': self.mn.collateral_vout },
@@ -128,46 +123,77 @@ def destroy_mn(self, test: BitcoinTestFramework):
                 {self.mn.fundsAddr: float(address_funds_value - Decimal(0.001))}
             ])
         raw_tx = self.node.signrawtransactionwithwallet(raw_tx)['hex']
-
         # Send that transaction, resulting txid is new collateral
         new_collateral_txid = self.node.sendrawtransaction(raw_tx)
         self.mn.bury_tx(test, self.mn.nodeIdx, new_collateral_txid, 1)
         new_collateral_vout = self.mn.get_collateral_vout(self.node, new_collateral_txid)
+        old_protx_hash = self.mn.proTxHash
         self.mn.set_params(proTxHash="", collateral_txid=new_collateral_txid, collateral_vout=new_collateral_vout)
-
         # Old masternode entry should be dead
-        assert_equal(self.is_mn_visible(self.mn.proTxHash), False)
-        test.log.debug(f"Destroyed {'Evo' if self.mn.evo else 'regular'} masternode with collateral_txid={self.mn.collateral_txid}, "
-                       f"collateral_vout={self.mn.collateral_vout}, provider_txid={self.mn.proTxHash}")
-
-        test.restart_node(self.mn.nodeIdx, extra_args=self.node.extra_args)
+        assert_equal(self.is_mn_visible(old_protx_hash), False)
+        test.log.debug(f"Destroyed EvoNode with collateral_txid={self.mn.collateral_txid}, collateral_vout={self.mn.collateral_vout}, provider_txid={old_protx_hash}")
 
 class NetInfoTest(BitcoinTestFramework):
     def set_test_params(self):
-        self.num_nodes = 2
-        self.extra_args = [
-            ["-dip3params=2:2"],
-            ["-deprecatedrpc=service", "-dip3params=2:2"]
-        ]
+        self.num_nodes = 3
+        self.extra_args = [[
+            "-dip3params=2:2", f"-vbparams=v23:{self.mocktime}:999999999999:{V23_ACTIVATION_THRESHOLD}:10:8:6:5:0"
+        ] for _ in range(self.num_nodes)]
+        self.extra_args[2] += ["-deprecatedrpc=service"]
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
-    def check_netinfo_fields(self, val, core_p2p_port: int):
-        assert_equal(val[0], f"127.0.0.1:{core_p2p_port}")
+    def activate_v23(self):
+        batch_size: int = 50
+        while not softfork_active(self.nodes[0], "v23"):
+            self.bump_mocktime(batch_size)
+            self.generate(self.nodes[0], batch_size, sync_fun=lambda: self.sync_blocks())
+        assert softfork_active(self.nodes[0], "v23")
+
+    def check_netinfo_fields(self, val, core_p2p_port: int, plat_https_port: Optional[int], plat_p2p_port: Optional[int]):
+        assert_equal(val['core_p2p'][0], f"127.0.0.1:{core_p2p_port}")
+        if plat_https_port:
+            assert_equal(val['platform_https'][0], f"127.0.0.1:{plat_https_port}")
+        if plat_p2p_port:
+            assert_equal(val['platform_p2p'][0], f"127.0.0.1:{plat_p2p_port}")
+
+    def extract_from_listdiff(self, rpc_output, proregtx_hash):
+        for arr in rpc_output['updatedMNs']:
+            if proregtx_hash in arr.keys():
+                return arr[proregtx_hash]
+        raise AssertionError(f"Unable to find {proregtx_hash} in array")
+
+    def reconnect_nodes(self):
+        # Needed as restarts don't reconnect nodes
+        for idx in range(1, self.num_nodes):
+            self.connect_nodes(0, idx)
 
     def run_test(self):
-        self.node_evo: Node = Node(self.nodes[0], True)
+        # Used for register RPC tests and payload reporting tests
+        self.node_evo: EvoNode = EvoNode(self.nodes[0])
         self.node_evo.generate_collateral(self)
-
-        self.node_simple: TestNode = self.nodes[1]
-
-        self.log.info("Test input validation for masternode address fields")
+        # Used for update RPC tests
+        self.node_two: EvoNode = EvoNode(self.nodes[1])
+        self.node_two.generate_collateral(self)
+        self.node_two.register_mn(self, True, "", DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP)
+        # Used to check deprecated field behavior
+        self.node_simple: TestNode = self.nodes[2]
+        # Test routines
+        self.log.info("Test input validation for masternode address fields (pre-fork)")
         self.test_validation_common()
         self.test_validation_legacy()
-
-        self.log.info("Test output masternode address fields for consistency")
+        self.log.info("Test output masternode address fields for consistency (pre-fork)")
         self.test_deprecation()
+        self.log.info("Mine blocks to activate DEPLOYMENT_V23")
+        self.activate_v23()
+        self.log.info("Test input validation for masternode address fields (post-fork)")
+        self.test_validation_common()
+        self.test_validation_extended()
+        self.log.info("Test masternode address fields for ProRegTx without addresses")
+        self.test_empty_fields()
+        self.log.info("Test output masternode address fields for consistency (post-fork)")
+        self.test_shims()
 
     def test_validation_common(self):
         # Arrays of addresses with invalid inputs get refused
@@ -176,20 +202,33 @@ def test_validation_common(self):
                                   -8, "Invalid param for coreP2PAddrs[0], must be string")
         self.node_evo.register_mn(self, False, [f"127.0.0.1:{self.node_evo.mn.nodePort}", ""],
                                   DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP,
-                                  -8, "Invalid param for coreP2PAddrs[1], cannot be empty string")
+                                  -8, "Invalid param for coreP2PAddrs[1], cannot be empty")
         self.node_evo.register_mn(self, False, [f"127.0.0.1:{self.node_evo.mn.nodePort}", self.node_evo.mn.nodePort],
                                   DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP,
                                   -8, "Invalid param for coreP2PAddrs[1], must be string")
 
-        # platformP2PPort and platformHTTPPort must be within acceptable range (i.e. a valid port number)
+        # platformP2PAddrs and platformHTTPSAddrs must be within acceptable range (i.e. a valid port number)
         self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", "0", DEFAULT_PORT_PLATFORM_HTTP,
-                                  -8, "platformP2PPort must be a valid port [1-65535]")
+                                  -8, "Invalid param for platformP2PAddrs, must be a valid port [1-65535]")
         self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", "65536", DEFAULT_PORT_PLATFORM_HTTP,
-                                  -8, "platformP2PPort must be a valid port [1-65535]")
+                                  -8, "Invalid param for platformP2PAddrs, must be a valid port [1-65535]")
         self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", DEFAULT_PORT_PLATFORM_P2P, "0",
-                                  -8, "platformHTTPPort must be a valid port [1-65535]")
+                                  -8, "Invalid param for platformHTTPSAddrs, must be a valid port [1-65535]")
         self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", DEFAULT_PORT_PLATFORM_P2P, "65536",
-                                  -8, "platformHTTPPort must be a valid port [1-65535]")
+                                  -8, "Invalid param for platformHTTPSAddrs, must be a valid port [1-65535]")
+
+        # coreP2PAddrs must be populated when updating a masternode
+        self.node_two.update_mn(self, False, "", DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP,
+                                -8, "Invalid param for coreP2PAddrs[0], cannot be empty")
+
+        # Legacy:   Normal registration of a masternode
+        # Extended: platformP2PAddrs and platformHTTPAddrs will be autopopulated with the addr from the first coreP2PAddrs entry
+        assert self.node_evo.node.testmempoolaccept([
+            self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}",
+                                      DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP)])[0]['allowed']
+        assert self.node_two.node.testmempoolaccept([
+            self.node_two.update_mn(self, False, f"127.0.0.1:{self.node_two.mn.nodePort}",
+                                    DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP)])[0]['allowed']
 
     def test_validation_legacy(self):
         # Using mainnet P2P port gets refused
@@ -202,15 +241,125 @@ def test_validation_legacy(self):
                                   DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP,
                                   -8, f"Error setting coreP2PAddrs[1] to '127.0.0.2:{self.node_evo.mn.nodePort}' (too many entries)")
 
-        # platformP2PPort and platformHTTPPort doesn't accept non-numeric inputs
+        # platformP2PAddrs and platformHTTPSAddrs don't accept non-numeric inputs
         self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", f"127.0.0.1:{DEFAULT_PORT_PLATFORM_P2P}", DEFAULT_PORT_PLATFORM_HTTP,
-                                  -8, f"platformP2PPort must be a 32bit integer (not '127.0.0.1:{DEFAULT_PORT_PLATFORM_P2P}')")
+                                  -8, "Invalid param for platformP2PAddrs, ProTx version only supports ports")
         self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", [f"127.0.0.1:{DEFAULT_PORT_PLATFORM_P2P}"], DEFAULT_PORT_PLATFORM_HTTP,
-                                  -8, "Invalid param for platformP2PPort, must be number")
+                                  -8, "Invalid param for platformP2PAddrs, ProTx version only supports ports")
         self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", DEFAULT_PORT_PLATFORM_P2P, f"127.0.0.1:{DEFAULT_PORT_PLATFORM_HTTP}",
-                                  -8, f"platformHTTPPort must be a 32bit integer (not '127.0.0.1:{DEFAULT_PORT_PLATFORM_HTTP}')")
+                                  -8, "Invalid param for platformHTTPSAddrs, ProTx version only supports ports")
         self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", DEFAULT_PORT_PLATFORM_P2P, [f"127.0.0.1:{DEFAULT_PORT_PLATFORM_HTTP}"],
-                                  -8, "Invalid param for platformHTTPPort, must be number")
+                                  -8, "Invalid param for platformHTTPSAddrs, ProTx version only supports ports")
+
+        # Port numbers may not be wrapped in arrays, either as integers or strings
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", [DEFAULT_PORT_PLATFORM_P2P], DEFAULT_PORT_PLATFORM_HTTP,
+                                  -8, "Invalid param for platformP2PAddrs, ProTx version only supports ports")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", [f"{DEFAULT_PORT_PLATFORM_P2P}"], DEFAULT_PORT_PLATFORM_HTTP,
+                                  -8, "Invalid param for platformP2PAddrs, ProTx version only supports ports")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", DEFAULT_PORT_PLATFORM_P2P, [DEFAULT_PORT_PLATFORM_HTTP],
+                                  -8, "Invalid param for platformHTTPSAddrs, ProTx version only supports ports")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", DEFAULT_PORT_PLATFORM_P2P, [f"{DEFAULT_PORT_PLATFORM_HTTP}"],
+                                  -8, "Invalid param for platformHTTPSAddrs, ProTx version only supports ports")
+
+        # coreP2PAddrs cannot be empty when registering a masternode without specifying platform fields
+        self.node_evo.register_mn(self, False, "", "", "",
+                                  -8, "Invalid param for platformP2PAddrs, ProTx version only supports ports")
+        self.node_evo.register_mn(self, False, "", "", DEFAULT_PORT_PLATFORM_HTTP,
+                                  -8, "Invalid param for platformP2PAddrs, ProTx version only supports ports")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", "", "",
+                                  -8, "Invalid param for platformP2PAddrs, cannot be empty if other fields populated")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", "", DEFAULT_PORT_PLATFORM_HTTP,
+                                  -8, "Invalid param for platformP2PAddrs, cannot be empty if other fields populated")
+        self.node_evo.register_mn(self, False, "", DEFAULT_PORT_PLATFORM_P2P, "",
+                                  -8, "Invalid param for platformHTTPSAddrs, ProTx version only supports ports")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", DEFAULT_PORT_PLATFORM_P2P, "",
+                                  -8, "Invalid param for platformHTTPSAddrs, cannot be empty if other fields populated")
+
+        # ...but it can empty if platform fields are specified
+        assert self.node_evo.node.testmempoolaccept([
+            self.node_evo.register_mn(self, False, "", DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP)])[0]['allowed']
+
+        # coreP2PAddrs can omit the port (supplying only addr) and it will be autopopulated with the default P2P port
+        assert self.node_evo.node.testmempoolaccept([
+            self.node_evo.register_mn(self, False, "127.0.0.1", DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP)])[0]['allowed']
+
+    def test_validation_extended(self):
+        # Using mainnet P2P port gets accepted
+        assert self.node_evo.node.testmempoolaccept([
+            self.node_evo.register_mn(self, False, f"127.0.0.1:{DEFAULT_PORT_MAINNET_CORE_P2P}",
+                                      DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP)])[0]['allowed']
+
+        # Arrays of addresses are recognized by address fields and are accepted
+        assert self.node_evo.node.testmempoolaccept([
+            self.node_evo.register_mn(self, False, [f"127.0.0.1:{self.node_evo.mn.nodePort}", f"127.0.0.2:{self.node_evo.mn.nodePort}"],
+                                      DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP)])[0]['allowed']
+        assert self.node_two.node.testmempoolaccept([
+            self.node_two.update_mn(self, False, [f"127.0.0.1:{self.node_two.mn.nodePort}", f"127.0.0.2:{self.node_two.mn.nodePort}"],
+                                    DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP)])[0]['allowed']
+        assert self.node_evo.node.testmempoolaccept([
+            self.node_evo.register_mn(self, False, [f"127.0.0.1:{self.node_evo.mn.nodePort}", f"127.0.0.2:{self.node_evo.mn.nodePort}"],
+                                      [f"127.0.0.1:{DEFAULT_PORT_PLATFORM_P2P}", f"127.0.0.2:{DEFAULT_PORT_PLATFORM_P2P}"],
+                                      [f"127.0.0.1:{DEFAULT_PORT_PLATFORM_HTTP}", f"127.0.0.2:{DEFAULT_PORT_PLATFORM_HTTP}"])])[0]['allowed']
+        assert self.node_two.node.testmempoolaccept([
+            self.node_two.update_mn(self, False, [f"127.0.0.1:{self.node_two.mn.nodePort}", f"127.0.0.2:{self.node_two.mn.nodePort}"],
+                                    [f"127.0.0.1:{DEFAULT_PORT_PLATFORM_P2P}", f"127.0.0.2:{DEFAULT_PORT_PLATFORM_P2P}"],
+                                    [f"127.0.0.1:{DEFAULT_PORT_PLATFORM_HTTP}", f"127.0.0.2:{DEFAULT_PORT_PLATFORM_HTTP}"])])[0]['allowed']
+
+        # ...but duplicates across and within those fields are not
+        self.node_evo.register_mn(self, False, [f"127.0.0.1:{self.node_evo.mn.nodePort}", f"127.0.0.2:{self.node_evo.mn.nodePort}"],
+                                  [f"127.0.0.1:{self.node_evo.mn.nodePort}", f"127.0.0.2:{self.node_evo.mn.nodePort}"],
+                                  [f"127.0.0.1:{DEFAULT_PORT_PLATFORM_HTTP}", f"127.0.0.2:{DEFAULT_PORT_PLATFORM_HTTP}"],
+                                  -8, f"Error setting platformP2PAddrs[0] to '127.0.0.1:{self.node_evo.mn.nodePort}' (duplicate)")
+        self.node_evo.register_mn(self, False, [f"127.0.0.1:{self.node_evo.mn.nodePort}", f"127.0.0.2:{self.node_evo.mn.nodePort}"],
+                                  [f"127.0.0.1:{DEFAULT_PORT_PLATFORM_P2P}", f"127.0.0.1:{DEFAULT_PORT_PLATFORM_P2P}"],
+                                  [f"127.0.0.1:{DEFAULT_PORT_PLATFORM_HTTP}", f"127.0.0.2:{DEFAULT_PORT_PLATFORM_HTTP}"],
+                                  -8, f"Error setting platformP2PAddrs[1] to '127.0.0.1:{DEFAULT_PORT_PLATFORM_P2P}' (duplicate)")
+
+        # platformP2PAddrs and platformHTTPSAddrs accept non-numeric inputs
+        assert self.node_evo.node.testmempoolaccept([
+            self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", f"127.0.0.1:{DEFAULT_PORT_PLATFORM_P2P}",
+                                      DEFAULT_PORT_PLATFORM_HTTP)])[0]['allowed']
+        assert self.node_evo.node.testmempoolaccept([
+            self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", [f"127.0.0.1:{DEFAULT_PORT_PLATFORM_P2P}"],
+                                      DEFAULT_PORT_PLATFORM_HTTP)])[0]['allowed']
+        assert self.node_evo.node.testmempoolaccept([
+            self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", DEFAULT_PORT_PLATFORM_P2P,
+                                      f"127.0.0.1:{DEFAULT_PORT_PLATFORM_HTTP}")])[0]['allowed']
+        assert self.node_evo.node.testmempoolaccept([
+            self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", DEFAULT_PORT_PLATFORM_P2P,
+                                      [f"127.0.0.1:{DEFAULT_PORT_PLATFORM_HTTP}"])])[0]['allowed']
+
+        # Port numbers may not be wrapped in arrays, either as integers or strings
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", [DEFAULT_PORT_PLATFORM_P2P], DEFAULT_PORT_PLATFORM_HTTP,
+                                  -8, "Invalid param for platformP2PAddrs[0], must be string")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", [f"{DEFAULT_PORT_PLATFORM_P2P}"], DEFAULT_PORT_PLATFORM_HTTP,
+                                  -8, "Invalid param for platformP2PAddrs[0], must be string")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", DEFAULT_PORT_PLATFORM_P2P, [DEFAULT_PORT_PLATFORM_HTTP],
+                                  -8, "Invalid param for platformHTTPSAddrs[0], must be string")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", DEFAULT_PORT_PLATFORM_P2P, [f"{DEFAULT_PORT_PLATFORM_HTTP}"],
+                                  -8, "Invalid param for platformHTTPSAddrs[0], must be string")
+
+        # coreP2PAddrs can be empty when registering a masternode if platform fields are not specified
+        assert self.node_evo.node.testmempoolaccept([
+            self.node_evo.register_mn(self, False, "", "", "")])[0]['allowed']
+
+        # ...but it cannot empty if any address field is specified
+        self.node_evo.register_mn(self, False, "", DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP,
+                                  -8, "Cannot set param for platformP2PAddrs, must specify coreP2PAddrs first")
+        self.node_evo.register_mn(self, False, "", "", DEFAULT_PORT_PLATFORM_HTTP,
+                                  -8, "Cannot set param for platformHTTPSAddrs, must specify coreP2PAddrs first")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", "", "",
+                                  -8, "Invalid param for platformP2PAddrs, cannot be empty if other fields populated")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", "", DEFAULT_PORT_PLATFORM_HTTP,
+                                  -8, "Invalid param for platformP2PAddrs, cannot be empty if other fields populated")
+        self.node_evo.register_mn(self, False, "", DEFAULT_PORT_PLATFORM_P2P, "",
+                                  -8, "Cannot set param for platformP2PAddrs, must specify coreP2PAddrs first")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.mn.nodePort}", DEFAULT_PORT_PLATFORM_P2P, "",
+                                  -8, "Invalid param for platformHTTPSAddrs, cannot be empty if other fields populated")
+
+        # coreP2PAddrs cannot omit the port, extended addresses require explicit port specification
+        self.node_evo.register_mn(self, False, "127.0.0.1", DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP,
+                                  -8, "Error setting coreP2PAddrs[0] to '127.0.0.1' (invalid port)")
 
     def test_deprecation(self):
         # netInfo is represented with JSON in CProRegTx, CProUpServTx, CDeterministicMNState and CSimplifiedMNListEntry,
@@ -222,27 +371,32 @@ def test_deprecation(self):
         proregtx_rpc = self.node_evo.node.getrawtransaction(proregtx_hash, True)
 
         # CDeterministicMNState::ToJson() <- CDeterministicMN::pdmnState <- masternode_status
+        self.node_evo.set_active_state(self, True)
         masternode_status = self.node_evo.node.masternode('status')
 
         # Generate deprecation-disabled response to avoid having to re-create a masternode again later on
-        self.restart_node(self.node_evo.mn.nodeIdx, extra_args=self.node_evo.node.extra_args +
-                          [f'-masternodeblsprivkey={self.node_evo.mn.keyOperator}', '-deprecatedrpc=service'])
-        self.connect_nodes(self.node_evo.mn.nodeIdx, self.node_simple.index) # Needed as restarts don't reconnect nodes
+        self.node_evo.set_active_state(self, True, ['-deprecatedrpc=service'])
+        self.reconnect_nodes()
         masternode_status_depr = self.node_evo.node.masternode('status')
 
         # Stop actively running the masternode so we can issue a CProUpServTx (and enable the deprecation)
-        self.restart_node(self.node_evo.mn.nodeIdx, extra_args=self.node_evo.node.extra_args)
-        self.connect_nodes(self.node_evo.mn.nodeIdx, self.node_simple.index) # Needed as restarts don't reconnect nodes
+        self.node_evo.set_active_state(self, False)
+        self.reconnect_nodes()
 
         # CProUpServTx::ToJson() <- TxToUniv() <- TxToJSON() <- getrawtransaction
-        proupservtx_hash = self.node_evo.update_mn(self, f"127.0.0.1:{self.node_evo.mn.nodePort+1}", DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP)
+        # We need to update *thrice*, the first time to incorrect values and the second time, (back) to correct values and the third time, only
+        # updating Platform fields to trigger the conditions needed to report the dummy address
+        proupservtx_hash = self.node_evo.update_mn(self, True, f"127.0.0.1:{self.node_evo.mn.nodePort + 10}", DEFAULT_PORT_PLATFORM_P2P + 10, DEFAULT_PORT_PLATFORM_HTTP + 10)
         proupservtx_rpc = self.node_evo.node.getrawtransaction(proupservtx_hash, True)
 
-        # We need to update *twice*, the first time to incorrect values and the second time, back to correct values.
-        # This is to make sure that the fields we need to check against are reflected in the diff.
-        proupservtx_hash = self.node_evo.update_mn(self, f"127.0.0.1:{self.node_evo.mn.nodePort}", DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP)
+        # Restore back to defaults
+        proupservtx_hash = self.node_evo.update_mn(self, True, f"127.0.0.1:{self.node_evo.mn.nodePort}", DEFAULT_PORT_PLATFORM_P2P, DEFAULT_PORT_PLATFORM_HTTP)
         proupservtx_rpc = self.node_evo.node.getrawtransaction(proupservtx_hash, True)
 
+        # Revert back to incorrect values but only for Platform fields
+        proupservtx_hash_pl = self.node_evo.update_mn(self, True, f"127.0.0.1:{self.node_evo.mn.nodePort}", DEFAULT_PORT_PLATFORM_P2P + 10, DEFAULT_PORT_PLATFORM_HTTP + 10)
+        proupservtx_rpc_pl = self.node_evo.node.getrawtransaction(proupservtx_hash_pl, True)
+
         # CSimplifiedMNListEntry::ToJson() <- CSimplifiedMNListDiff::mnList <- CSimplifiedMNListDiff::ToJson() <- protx_diff
         masternode_active_height: int = masternode_status['dmnState']['registeredHeight']
         protx_diff_rpc = self.node_evo.node.protx('diff', masternode_active_height - 1, masternode_active_height)
@@ -250,33 +404,46 @@ def test_deprecation(self):
         # CDeterministicMNStateDiff::ToJson() <- CDeterministicMNListDiff::updatedMns <- protx_listdiff
         proupservtx_height = proupservtx_rpc['height']
         protx_listdiff_rpc = self.node_evo.node.protx('listdiff', proupservtx_height - 1, proupservtx_height)
+        protx_listdiff_rpc = self.extract_from_listdiff(protx_listdiff_rpc, proregtx_hash)
+
+        # If the core P2P address wasn't updated and the platform fields were, CDeterministicMNStateDiff will return a dummy address
+        proupservtx_height_pl = proupservtx_rpc_pl['height']
+        protx_listdiff_rpc_pl = self.node_evo.node.protx('listdiff', proupservtx_height_pl - 1, proupservtx_height_pl)
+        protx_listdiff_rpc_pl = self.extract_from_listdiff(protx_listdiff_rpc_pl, proregtx_hash)
 
         self.log.info("Test RPCs return an 'addresses' field")
         assert "addresses" in proregtx_rpc['proRegTx'].keys()
         assert "addresses" in masternode_status['dmnState'].keys()
         assert "addresses" in proupservtx_rpc['proUpServTx'].keys()
         assert "addresses" in protx_diff_rpc['mnList'][0].keys()
-        assert "addresses" in protx_listdiff_rpc['updatedMNs'][0][proregtx_hash].keys()
+        assert "addresses" in protx_listdiff_rpc.keys()
 
         self.log.info("Test 'addresses' report correctly")
-        self.check_netinfo_fields(proregtx_rpc['proRegTx']['addresses'], self.node_evo.mn.nodePort)
-        self.check_netinfo_fields(masternode_status['dmnState']['addresses'], self.node_evo.mn.nodePort)
-        self.check_netinfo_fields(proupservtx_rpc['proUpServTx']['addresses'], self.node_evo.mn.nodePort)
-        self.check_netinfo_fields(protx_diff_rpc['mnList'][0]['addresses'], self.node_evo.mn.nodePort)
-        self.check_netinfo_fields(protx_listdiff_rpc['updatedMNs'][0][proregtx_hash]['addresses'], self.node_evo.mn.nodePort)
+        self.check_netinfo_fields(proregtx_rpc['proRegTx']['addresses'], self.node_evo.mn.nodePort, DEFAULT_PORT_PLATFORM_HTTP, DEFAULT_PORT_PLATFORM_P2P)
+        self.check_netinfo_fields(masternode_status['dmnState']['addresses'], self.node_evo.mn.nodePort, DEFAULT_PORT_PLATFORM_HTTP, DEFAULT_PORT_PLATFORM_P2P)
+        self.check_netinfo_fields(proupservtx_rpc['proUpServTx']['addresses'], self.node_evo.mn.nodePort, DEFAULT_PORT_PLATFORM_HTTP, DEFAULT_PORT_PLATFORM_P2P)
+        # CSimplifiedMNListEntry doesn't store platform P2P network information before extended addresses
+        self.check_netinfo_fields(protx_diff_rpc['mnList'][0]['addresses'], self.node_evo.mn.nodePort, DEFAULT_PORT_PLATFORM_HTTP, None)
+        # CDeterministicMNStateDiff will fill in the correct address if the core P2P address was updated *alongside* platform fields
+        self.check_netinfo_fields(protx_listdiff_rpc['addresses'], self.node_evo.mn.nodePort, DEFAULT_PORT_PLATFORM_HTTP, DEFAULT_PORT_PLATFORM_P2P)
+        # CDeterministicMNStateDiff will use a dummy address if the core P2P address wasn't updated but Platform fields were to ensure changes are reported
+        assert "core_p2p" not in protx_listdiff_rpc_pl['addresses'].keys()
+        assert_equal(protx_listdiff_rpc_pl['addresses']['platform_https'][0], f"{DMNSTATE_DIFF_DUMMY_ADDR}:{DEFAULT_PORT_PLATFORM_HTTP + 10}")
+        assert_equal(protx_listdiff_rpc_pl['addresses']['platform_p2p'][0], f"{DMNSTATE_DIFF_DUMMY_ADDR}:{DEFAULT_PORT_PLATFORM_P2P + 10}")
 
         self.log.info("Test RPCs by default no longer return a 'service' field")
         assert "service" not in proregtx_rpc['proRegTx'].keys()
         assert "service" not in masternode_status['dmnState'].keys()
         assert "service" not in proupservtx_rpc['proUpServTx'].keys()
         assert "service" not in protx_diff_rpc['mnList'][0].keys()
-        assert "service" not in protx_listdiff_rpc['updatedMNs'][0][proregtx_hash].keys()
+        assert "service" not in protx_listdiff_rpc.keys()
         # "service" in "masternode status" is exempt from the deprecation as the primary address is
         # relevant on the host node as opposed to expressing payload information in most other RPCs.
         assert "service" in masternode_status.keys()
 
-        self.node_evo.destroy_mn(self) # Shut down previous masternode
-        self.connect_nodes(self.node_evo.mn.nodeIdx, self.node_simple.index) # Needed as restarts don't reconnect nodes
+        # Shut down masternode
+        self.node_evo.destroy_mn(self)
+        self.reconnect_nodes()
 
         self.log.info("Collect RPC responses from node with -deprecatedrpc=service")
 
@@ -286,13 +453,108 @@ def test_deprecation(self):
         protx_diff_rpc = self.node_simple.protx('diff', masternode_active_height - 1, masternode_active_height)
         masternode_status = masternode_status_depr # Pull in response generated from earlier
         protx_listdiff_rpc = self.node_simple.protx('listdiff', proupservtx_height - 1, proupservtx_height)
+        protx_listdiff_rpc = self.extract_from_listdiff(protx_listdiff_rpc, proregtx_hash)
 
         self.log.info("Test RPCs return 'service' with -deprecatedrpc=service")
         assert "service" in proregtx_rpc['proRegTx'].keys()
         assert "service" in masternode_status['dmnState'].keys()
         assert "service" in proupservtx_rpc['proUpServTx'].keys()
         assert "service" in protx_diff_rpc['mnList'][0].keys()
-        assert "service" in protx_listdiff_rpc['updatedMNs'][0][proregtx_hash].keys()
+        assert "service" in protx_listdiff_rpc.keys()
+
+    def test_empty_fields(self):
+        def empty_common(grt_dict):
+            # Even if '[::]:0' is reported by 'service', 'addresses' should always be blank if we have nothing to report
+            assert_equal(len(grt_dict['addresses']), 0)
+            # 'service' will never be empty. Legacy addresses stored an empty CService, which evaluates to
+            # '[::]:0' when printed in string form. This behavior has been preserved for continuity.
+            assert_equal(grt_dict['service'], "[::]:0")
+
+        # Validate that our masternode was registered before the fork
+        grt_proregtx = self.node_simple.getrawtransaction(self.node_two.mn.proTxHash, True)['proRegTx']
+        assert_equal(grt_proregtx['version'], PROTXVER_BASIC)
+
+        # Test reporting on legacy address (i.e. basic BLS and earlier) nodes
+        empty_common(grt_proregtx)
+
+        # platform{P2P,HTTP}Port are non-optional fields for legacy addresses and will be populated
+        assert_equal(grt_proregtx['platformP2PPort'], DEFAULT_PORT_PLATFORM_P2P)
+        assert_equal(grt_proregtx['platformHTTPPort'], DEFAULT_PORT_PLATFORM_HTTP)
+
+        # Destroy and re-register node as blank
+        self.node_two.destroy_mn(self)
+        self.reconnect_nodes()
+        self.node_two.register_mn(self, True, "", "", "")
+
+        # Validate that masternode uses extended addresses
+        grt_proregtx = self.node_simple.getrawtransaction(self.node_two.mn.proTxHash, True)['proRegTx']
+        assert_equal(grt_proregtx['version'], PROTXVER_EXTADDR)
+
+        # Test reporting for extended addresses
+        empty_common(grt_proregtx)
+
+        # Extended addresses store addr:port pairs for platform{P2P,HTTPS}Addrs but ProRegTx allows blank
+        # address declarations (for later update with a ProUpServTx), this means that *unlike* legacy
+        # addresses, ProRegTxes that opt to omit addresses cannot report platform{P2P,HTTP}Port, which
+        # is signified with -1.
+        assert_equal(grt_proregtx['platformP2PPort'], -1)
+        assert_equal(grt_proregtx['platformHTTPPort'], -1)
+
+        # Destroy masternode
+        self.node_evo.destroy_mn(self)
+        self.reconnect_nodes()
+
+    def test_shims(self):
+        # There are two shims there to help with migrating between legacy and extended addresses, one reads from legacy platform
+        # fields to ensure 'addresses' is adequately populated. The other, reads from netInfo to populate platform{HTTP,P2P}Port.
+        # As the fork is now active, we can now evaluate the test cases that couldn't be evaluated in test_deprecation().
+        self.log.info("Collect JSON RPC responses from node")
+
+        # Create an masternode that clearly uses extended addresses (hello IPv6!)
+        proregtx_hash = self.node_evo.register_mn(self, True,
+                                                  [f"127.0.0.1:{self.node_evo.mn.nodePort}", f"[::1]:{self.node_evo.mn.nodePort}"],
+                                                  [f"127.0.0.2:{DEFAULT_PORT_PLATFORM_P2P}", f"[::2]:{DEFAULT_PORT_PLATFORM_P2P}"],
+                                                  [f"127.0.0.3:{DEFAULT_PORT_PLATFORM_HTTP}", f"[::3]:{DEFAULT_PORT_PLATFORM_HTTP}"])
+        proregtx_rpc = self.node_evo.node.getrawtransaction(proregtx_hash, True)
+
+        # Update only a platform field (platformP2PAddrs) but with an odd twist, we only specify the port number and expect the shim
+        # to auto-fill the addr portion from coreP2PAddrs[0]
+        proupservtx_hash = self.node_evo.update_mn(self, True,
+                                                   [f"127.0.0.1:{self.node_evo.mn.nodePort}", f"[::1]:{self.node_evo.mn.nodePort}"],
+                                                   DEFAULT_PORT_PLATFORM_P2P + 12,
+                                                   [f"127.0.0.3:{DEFAULT_PORT_PLATFORM_HTTP}", f"[::3]:{DEFAULT_PORT_PLATFORM_HTTP}"])
+        proupservtx_rpc = self.node_evo.node.getrawtransaction(proupservtx_hash, True)
+        assert_equal(proupservtx_rpc['proUpServTx']['addresses']['platform_p2p'][0], f"127.0.0.1:{DEFAULT_PORT_PLATFORM_P2P + 12}")
+
+        # Since all fields are stored in the netInfo, even though we updated only platformP2PAddrs, the dummy address should never be visible
+        # and *all* the addresses fields will be visible as they're now in one data structure
+        proupservtx_height = proupservtx_rpc['height']
+        protx_listdiff_rpc = self.node_evo.node.protx('listdiff', proupservtx_height - 1, proupservtx_height)
+        protx_listdiff_rpc = self.extract_from_listdiff(protx_listdiff_rpc, proregtx_hash)
+        assert_equal(protx_listdiff_rpc['addresses'], {
+            'core_p2p': [f"127.0.0.1:{self.node_evo.mn.nodePort}", f"[::1]:{self.node_evo.mn.nodePort}"],
+            'platform_p2p': [f"127.0.0.1:{DEFAULT_PORT_PLATFORM_P2P + 12}"],
+            'platform_https': [f"127.0.0.3:{DEFAULT_PORT_PLATFORM_HTTP}", f"[::3]:{DEFAULT_PORT_PLATFORM_HTTP}"]
+        })
+
+        # Check platform{HTTP,P2P}Port shims work as expected
+        assert_equal(proregtx_rpc['proRegTx']['platformP2PPort'], DEFAULT_PORT_PLATFORM_P2P)
+        assert_equal(proregtx_rpc['proRegTx']['platformHTTPPort'], DEFAULT_PORT_PLATFORM_HTTP)
+        assert_equal(proupservtx_rpc['proUpServTx']['platformP2PPort'], DEFAULT_PORT_PLATFORM_P2P + 12)
+        assert_equal(proupservtx_rpc['proUpServTx']['platformHTTPPort'], DEFAULT_PORT_PLATFORM_HTTP)
+        # platform{HTTP,P2P}Port *won't* be populated by listdiff as that *field* is now unused and it's dangerous to report "updates" to disused fields
+        assert "platformP2PPort" not in protx_listdiff_rpc.keys()
+        assert "platformHTTPPort" not in protx_listdiff_rpc.keys()
+
+        # Restart the client to see if (de)ser works as intended (CDeterministicMNStateDiff is a special case and we just made an update)
+        self.node_evo.set_active_state(self, False)
+        self.reconnect_nodes()
+
+        # Check that 'service' correctly reports as coreP2PAddrs[0]
+        proregtx_rpc = self.node_simple.getrawtransaction(proregtx_hash, True)
+        proupservtx_rpc = self.node_simple.getrawtransaction(proupservtx_hash, True)
+        assert_equal(proregtx_rpc['proRegTx']['service'], f"127.0.0.1:{self.node_evo.mn.nodePort}")
+        assert_equal(proupservtx_rpc['proUpServTx']['service'], f"127.0.0.1:{self.node_evo.mn.nodePort}")
 
 if __name__ == "__main__":
     NetInfoTest().main()
diff --git a/test/functional/rpc_quorum.py b/test/functional/rpc_quorum.py
index 202f0374c9d3..998049cf320b 100755
--- a/test/functional/rpc_quorum.py
+++ b/test/functional/rpc_quorum.py
@@ -28,7 +28,7 @@ def run_test(self):
             mn: MasternodeInfo = self.mninfo[idx]
             for member in quorum_info["members"]:
                 if member["proTxHash"] == mn.proTxHash:
-                    assert_equal(member['addresses'][0], f'127.0.0.1:{mn.nodePort}')
+                    assert_equal(member['addresses']['core_p2p'][0], f'127.0.0.1:{mn.nodePort}')
 
 if __name__ == '__main__':
     RPCMasternodeTest().main()
diff --git a/test/functional/test_framework/test_framework.py b/test/functional/test_framework/test_framework.py
index 9e9a20c415e9..2a1619090d1d 100755
--- a/test/functional/test_framework/test_framework.py
+++ b/test/functional/test_framework/test_framework.py
@@ -1220,28 +1220,32 @@ def get_node(self, test: BitcoinTestFramework) -> TestNode:
             raise AssertionError(f"Node at pos {self.nodeIdx} not present, did you start the node?")
         return test.nodes[self.nodeIdx]
 
-    def register(self, node: TestNode, submit: bool, collateral_txid: Optional[str] = None, collateral_vout: Optional[int] = None,
-                 coreP2PAddrs: 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, platform_p2p_port: Optional[int] = None, platform_http_port: Optional[int] = None,
-                 expected_assert_code: Optional[int] = None, expected_assert_msg: Optional[str] = None) -> Optional[str]:
+    def validate_inputs(self, 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):
         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")
-
-        # EvoNode-specific fields are ignored for regular masternodes
         if self.evo:
             if platform_node_id is None:
                 raise AssertionError("EvoNode but platform_node_id is missing, must be specified!")
-            if platform_p2p_port is None:
-                raise AssertionError("EvoNode but platform_p2p_port is missing, must be specified!")
-            if platform_http_port is None:
-                raise AssertionError("EvoNode but platform_http_port is missing, must be specified!")
+            if addrs_platform_p2p is None:
+                raise AssertionError("EvoNode but addrs_platform_p2p is missing, must be specified!")
+            if addrs_platform_https is None:
+                raise AssertionError("EvoNode but addrs_platform_https is missing, must be specified!")
+
+    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,
+                 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)
 
         # Common arguments shared between regular masternodes and EvoNodes
         args = [
             collateral_txid or self.collateral_txid,
             collateral_vout or self.collateral_vout,
-            coreP2PAddrs or [f'127.0.0.1:{self.nodePort}'],
+            [f'127.0.0.1:{self.nodePort}'] if addrs_core_p2p is None else addrs_core_p2p,
             ownerAddr or self.ownerAddr,
             pubKeyOperator or self.pubKeyOperator,
             votingAddr or self.votingAddr,
@@ -1261,7 +1265,7 @@ def register(self, node: TestNode, submit: bool, collateral_txid: Optional[str]
         # Construct final command and arguments
         if self.evo:
             command = "register_evo"
-            args = args + [platform_node_id, platform_p2p_port, platform_http_port, address_funds, submit] # type: ignore
+            args = args + [platform_node_id, addrs_platform_p2p, addrs_platform_https, address_funds, submit] # type: ignore
         else:
             command = "register_legacy" if self.legacy else "register"
             args = args + [address_funds, submit] # type: ignore
@@ -1276,22 +1280,13 @@ def register(self, node: TestNode, submit: bool, collateral_txid: Optional[str]
 
         return ret
 
-    def register_fund(self, node: TestNode, submit: bool, collateral_address: Optional[str] = None, coreP2PAddrs: Union[str, List[str], None] = None,
+    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,
-                      platform_node_id: Optional[str] = None, platform_p2p_port: Optional[int] = None, platform_http_port: Optional[int] = 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")
-
-        # EvoNode-specific fields are ignored for regular masternodes
-        if self.evo:
-            if platform_node_id is None:
-                raise AssertionError("EvoNode but platform_node_id is missing, must be specified!")
-            if platform_p2p_port is None:
-                raise AssertionError("EvoNode but platform_p2p_port is missing, must be specified!")
-            if platform_http_port is None:
-                raise AssertionError("EvoNode but platform_http_port is missing, must be specified!")
+                      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)
 
         # Use assert_raises_rpc_error if we expect to error out
         use_assert: bool = bool(expected_assert_code and expected_assert_msg)
@@ -1304,7 +1299,7 @@ def register_fund(self, node: TestNode, submit: bool, collateral_address: Option
         # Common arguments shared between regular masternodes and EvoNodes
         args = [
             collateral_address or self.collateral_address,
-            coreP2PAddrs or [f'127.0.0.1:{self.nodePort}'],
+            [f'127.0.0.1:{self.nodePort}'] if addrs_core_p2p is None else addrs_core_p2p,
             ownerAddr or self.ownerAddr,
             pubKeyOperator or self.pubKeyOperator,
             votingAddr or self.votingAddr,
@@ -1316,7 +1311,7 @@ def register_fund(self, node: TestNode, submit: bool, collateral_address: Option
         # Construct final command and arguments
         if self.evo:
             command = "register_fund_evo"
-            args = args + [platform_node_id, platform_p2p_port, platform_http_port, address_funds, submit] # type: ignore
+            args = args + [platform_node_id, addrs_platform_p2p, addrs_platform_https, address_funds, submit] # type: ignore
         else:
             command = "register_fund_legacy" if self.legacy else "register_fund"
             args = args + [address_funds, submit] # type: ignore
@@ -1415,11 +1410,11 @@ def update_registrar(self, node: TestNode, submit: bool, pubKeyOperator: Optiona
 
         return ret
 
-    def update_service(self, node: TestNode, submit: bool, coreP2PAddrs: Union[str, List[str], None] = None, platform_node_id: Optional[str] = None, platform_p2p_port: Optional[int] = None,
-                       platform_http_port: Optional[int] = None, address_operator: Optional[str] = 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")
+    def update_service(self, node: TestNode, submit: bool, addrs_core_p2p: Union[str, List[str], None] = 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,
+                       address_operator: Optional[str] = None, fundsAddr: Optional[str] = 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)
 
         # Update commands should be run from the appropriate MasternodeInfo instance, we do not allow overriding some values for this reason
         if self.proTxHash is None:
@@ -1427,15 +1422,6 @@ def update_service(self, node: TestNode, submit: bool, coreP2PAddrs: Union[str,
         if self.keyOperator is None:
             raise AssertionError("keyOperator not set, did you call generate_addresses()")
 
-        # EvoNode-specific fields are ignored for regular masternodes
-        if self.evo:
-            if platform_node_id is None:
-                raise AssertionError("EvoNode but platform_node_id is missing, must be specified!")
-            if platform_p2p_port is None:
-                raise AssertionError("EvoNode but platform_p2p_port is missing, must be specified!")
-            if platform_http_port is None:
-                raise AssertionError("EvoNode but platform_http_port is missing, must be specified!")
-
         # Use assert_raises_rpc_error if we expect to error out
         use_assert: bool = bool(expected_assert_code and expected_assert_msg)
 
@@ -1447,7 +1433,7 @@ def update_service(self, node: TestNode, submit: bool, coreP2PAddrs: Union[str,
         # Common arguments shared between regular masternodes and EvoNodes
         args = [
             self.proTxHash,
-            coreP2PAddrs or [f'127.0.0.1:{self.nodePort}'],
+            [f'127.0.0.1:{self.nodePort}'] if addrs_core_p2p is None else addrs_core_p2p,
             self.keyOperator,
         ]
         address_funds = fundsAddr or self.fundsAddr
@@ -1456,7 +1442,7 @@ def update_service(self, node: TestNode, submit: bool, coreP2PAddrs: Union[str,
         # Construct final command and arguments
         if self.evo:
             command = "update_service_evo"
-            args = args + [platform_node_id, platform_p2p_port, platform_http_port, address_operator, address_funds, submit] # type: ignore
+            args = args + [platform_node_id, addrs_platform_p2p, addrs_platform_https, address_operator, address_funds, submit] # type: ignore
         else:
             command = "update_service"
             args = args + [address_operator, address_funds, submit] # type: ignore
@@ -1641,8 +1627,8 @@ def dynamically_prepare_masternode(self, idx, node_p2p_port, evo=False, rnd=None
         mn.generate_addresses(self.nodes[0])
 
         platform_node_id = hash160(b'%d' % rnd).hex() if rnd is not None else hash160(b'%d' % node_p2p_port).hex()
-        platform_p2p_port = node_p2p_port + 101
-        platform_http_port = node_p2p_port + 102
+        addrs_platform_p2p = node_p2p_port + 101
+        addrs_platform_https = node_p2p_port + 102
 
         outputs = {mn.collateral_address: mn.get_collateral_value(), mn.fundsAddr: 1}
         collateral_txid = self.nodes[0].sendmany("", outputs)
@@ -1650,12 +1636,12 @@ def dynamically_prepare_masternode(self, idx, node_p2p_port, evo=False, rnd=None
         mn.bury_tx(self, genIdx=0, txid=collateral_txid, depth=1)
         collateral_vout = mn.get_collateral_vout(self.nodes[0], collateral_txid)
 
-        coreP2PAddrs = ['127.0.0.1:%d' % node_p2p_port]
+        addrs_core_p2p = ['127.0.0.1:%d' % node_p2p_port]
         operatorReward = idx
 
-        # platform_node_id, platform_p2p_port and platform_http_port are ignored for regular masternodes
-        protx_result = mn.register(self.nodes[0], submit=True, collateral_txid=collateral_txid, collateral_vout=collateral_vout, coreP2PAddrs=coreP2PAddrs, operator_reward=operatorReward,
-                                   platform_node_id=platform_node_id, platform_p2p_port=platform_p2p_port, platform_http_port=platform_http_port)
+        # platform_node_id, addrs_platform_p2p and addrs_platform_https are ignored for regular masternodes
+        protx_result = mn.register(self.nodes[0], submit=True, collateral_txid=collateral_txid, collateral_vout=collateral_vout, addrs_core_p2p=addrs_core_p2p, operator_reward=operatorReward,
+                                   platform_node_id=platform_node_id, addrs_platform_p2p=addrs_platform_p2p, addrs_platform_https=addrs_platform_https)
         assert protx_result is not None
 
         self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
@@ -1675,8 +1661,8 @@ def dynamically_evo_update_service(self, evo_info: MasternodeInfo, rnd=None, sho
         # For the sake of the test, generate random nodeid, p2p and http platform values
         r = rnd if rnd is not None else random.randint(21000, 65000)
         platform_node_id = hash160(b'%d' % r).hex()
-        platform_p2p_port = r + 1
-        platform_http_port = r + 2
+        addrs_platform_p2p = r + 1
+        addrs_platform_https = r + 2
 
         fund_txid = self.nodes[0].sendtoaddress(funds_address, 1)
         self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
@@ -1684,11 +1670,11 @@ def dynamically_evo_update_service(self, evo_info: MasternodeInfo, rnd=None, sho
 
         protx_success = False
         try:
-            protx_result = evo_info.update_service(self.nodes[0], True, f'127.0.0.1:{evo_info.nodePort}', platform_node_id, platform_p2p_port, platform_http_port, operator_reward_address, funds_address)
+            protx_result = evo_info.update_service(self.nodes[0], True, f'127.0.0.1:{evo_info.nodePort}', platform_node_id, addrs_platform_p2p, addrs_platform_https, operator_reward_address, funds_address)
             assert protx_result is not None
             self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
             evo_info.bury_tx(self, genIdx=0, txid=protx_result, depth=1)
-            self.log.info("Updated EvoNode %s: platformNodeID=%s, platformP2PPort=%s, platformHTTPPort=%s" % (evo_info.proTxHash, platform_node_id, platform_p2p_port, platform_http_port))
+            self.log.info("Updated EvoNode %s: platformNodeID=%s, platformP2PPort=%s, platformHTTPPort=%s" % (evo_info.proTxHash, platform_node_id, addrs_platform_p2p, addrs_platform_https))
             protx_success = True
         except:
             self.log.info("protx_evo rejected")
@@ -1716,16 +1702,16 @@ def prepare_masternode(self, idx):
         self.nodes[0].sendtoaddress(mn.fundsAddr, 0.001)
 
         port = p2p_port(len(self.nodes) + idx)
-        coreP2PAddrs = ['127.0.0.1:%d' % port]
+        addrs_core_p2p = ['127.0.0.1:%d' % port]
         operatorReward = idx
 
         submit = (idx % 4) < 2
 
         if register_fund:
-            protx_result = mn.register_fund(self.nodes[0], submit=submit, coreP2PAddrs=coreP2PAddrs, operator_reward=operatorReward)
+            protx_result = mn.register_fund(self.nodes[0], submit=submit, addrs_core_p2p=addrs_core_p2p, operator_reward=operatorReward)
         else:
             self.generate(self.nodes[0], 1, sync_fun=self.no_op)
-            protx_result = mn.register(self.nodes[0], submit=submit, collateral_txid=txid, collateral_vout=collateral_vout, coreP2PAddrs=coreP2PAddrs,
+            protx_result = mn.register(self.nodes[0], submit=submit, collateral_txid=txid, collateral_vout=collateral_vout, addrs_core_p2p=addrs_core_p2p,
                                        operator_reward=operatorReward)
         if submit:
             proTxHash = protx_result
@@ -1737,7 +1723,7 @@ def prepare_masternode(self, idx):
         if operatorReward > 0:
             self.generate(self.nodes[0], 1, sync_fun=self.no_op)
             operatorPayoutAddress = self.nodes[0].getnewaddress()
-            mn.update_service(self.nodes[0], submit=True, coreP2PAddrs=coreP2PAddrs, address_operator=operatorPayoutAddress)
+            mn.update_service(self.nodes[0], submit=True, addrs_core_p2p=addrs_core_p2p, address_operator=operatorPayoutAddress)
 
         self.mninfo.append(mn)
         self.log.info("Prepared MN %d: collateral_txid=%s, collateral_vout=%d, protxHash=%s" % (idx, txid, collateral_vout, proTxHash))