diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index 08468ca9c5b9..e9aa068ab97a 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -9,12 +9,13 @@
 #include <evo/providertx.h>
 #include <evo/simplifiedmns.h>
 #include <evo/specialtx.h>
-#include <index/txindex.h>
 
 #include <chainparams.h>
 #include <coins.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
+#include <index/txindex.h>
+#include <masternode/meta.h>
 #include <messagesigner.h>
 #include <node/blockstorage.h>
 #include <script/standard.h>
@@ -641,6 +642,23 @@ bool CDeterministicMNManager::ProcessBlock(const CBlock& block, gsl::not_null<co
         oldList = GetListForBlockInternal(pindex->pprev);
         diff = oldList.BuildDiff(newList);
 
+        // apply platform unban for platform revive too
+        for (int i = 1; i < (int)block.vtx.size(); i++) {
+            const CTransaction& tx = *block.vtx[i];
+            if (!tx.IsSpecialTxVersion() || tx.nType != TRANSACTION_PROVIDER_UPDATE_SERVICE) {
+                // only interested in revive transactions
+                continue;
+            }
+            const auto opt_proTx = GetTxPayload<CProUpServTx>(tx);
+            if (!opt_proTx) continue; // should not happen but does not matter
+
+            if (auto meta_info = m_mn_metaman.GetMetaInfo(opt_proTx->proTxHash, false);
+                !meta_info || !meta_info->SetPlatformBan(false, nHeight)) {
+                LogPrint(BCLog::LLMQ, "%s -- MN %s is failed to Platform revived at height %d\n", __func__,
+                         opt_proTx->proTxHash.ToString(), nHeight);
+            }
+        }
+
         m_evoDb.Write(std::make_pair(DB_LIST_DIFF, newList.GetBlockHash()), diff);
         if ((nHeight % DISK_SNAPSHOT_PERIOD) == 0 || pindex->pprev == m_initial_snapshot_index) {
             m_evoDb.Write(std::make_pair(DB_LIST_SNAPSHOT, newList.GetBlockHash()), newList);
diff --git a/src/evo/deterministicmns.h b/src/evo/deterministicmns.h
index 9c106c5fe941..17bcefbd4ffb 100644
--- a/src/evo/deterministicmns.h
+++ b/src/evo/deterministicmns.h
@@ -32,6 +32,7 @@ class CCoinsViewCache;
 class CEvoDB;
 class CSimplifiedMNList;
 class CSimplifiedMNListEntry;
+class CMasternodeMetaMan;
 class TxValidationState;
 
 extern RecursiveMutex cs_main;
@@ -626,6 +627,7 @@ class CDeterministicMNManager
     std::atomic<int> to_cleanup {0};
 
     CEvoDB& m_evoDb;
+    CMasternodeMetaMan& m_mn_metaman;
 
     std::unordered_map<uint256, CDeterministicMNList, StaticSaltedHasher> mnListsCache GUARDED_BY(cs);
     std::unordered_map<uint256, CDeterministicMNListDiff, StaticSaltedHasher> mnListDiffsCache GUARDED_BY(cs);
@@ -633,8 +635,9 @@ class CDeterministicMNManager
     const CBlockIndex* m_initial_snapshot_index GUARDED_BY(cs) {nullptr};
 
 public:
-    explicit CDeterministicMNManager(CEvoDB& evoDb) :
-        m_evoDb(evoDb)
+    explicit CDeterministicMNManager(CEvoDB& evoDb, CMasternodeMetaMan& mn_metaman) :
+        m_evoDb(evoDb),
+        m_mn_metaman(mn_metaman)
     {
     }
     ~CDeterministicMNManager() = default;
diff --git a/src/llmq/dkgsession.cpp b/src/llmq/dkgsession.cpp
index 2fb687772808..2c9e2e9b2218 100644
--- a/src/llmq/dkgsession.cpp
+++ b/src/llmq/dkgsession.cpp
@@ -492,11 +492,15 @@ void CDKGSession::VerifyConnectionAndMinProtoVersions(CConnman& connman) const
             m->badConnection = true;
             logger.Batch("%s does not have min proto version %d (has %d)", m->dmn->proTxHash.ToString(), MIN_MASTERNODE_PROTO_VERSION, it->second);
         }
-
-        if (m_mn_metaman.GetMetaInfo(m->dmn->proTxHash)->OutboundFailedTooManyTimes()) {
+        const auto meta_info = m_mn_metaman.GetMetaInfo(m->dmn->proTxHash);
+        if (meta_info->OutboundFailedTooManyTimes()) {
             m->badConnection = true;
             logger.Batch("%s failed to connect to it too many times", m->dmn->proTxHash.ToString());
         }
+        if (meta_info->IsPlatformBanned()) {
+            m->badConnection = true;
+            logger.Batch("%s is Platform PoSe banned", m->dmn->proTxHash.ToString());
+        }
     }
 }
 
diff --git a/src/masternode/meta.cpp b/src/masternode/meta.cpp
index 72a1370ad997..adb2aaa30259 100644
--- a/src/masternode/meta.cpp
+++ b/src/masternode/meta.cpp
@@ -8,7 +8,7 @@
 #include <univalue.h>
 #include <util/time.h>
 
-const std::string MasternodeMetaStore::SERIALIZATION_VERSION_STRING = "CMasternodeMetaMan-Version-3";
+const std::string MasternodeMetaStore::SERIALIZATION_VERSION_STRING = "CMasternodeMetaMan-Version-4";
 
 CMasternodeMetaMan::CMasternodeMetaMan() :
     m_db{std::make_unique<db_type>("mncache.dat", "magicMasternodeCache")}
@@ -41,6 +41,11 @@ UniValue CMasternodeMetaInfo::ToJson() const
     ret.pushKV("lastOutboundAttemptElapsed", now - lastOutboundAttempt.load());
     ret.pushKV("lastOutboundSuccess", lastOutboundSuccess.load());
     ret.pushKV("lastOutboundSuccessElapsed", now - lastOutboundSuccess.load());
+    {
+        LOCK(cs);
+        ret.pushKV("is_platform_banned", m_platform_ban);
+        ret.pushKV("platform_ban_height_updated", m_platform_ban_updated);
+    }
 
     return ret;
 }
@@ -125,8 +130,33 @@ std::vector<uint256> CMasternodeMetaMan::GetAndClearDirtyGovernanceObjectHashes(
     return vecTmp;
 }
 
+bool CMasternodeMetaMan::AlreadyHavePlatformBan(const uint256& inv_hash) const
+{
+    LOCK(cs);
+    return m_seen_platform_bans.exists(inv_hash);
+}
+
+std::optional<PlatformBanMessage> CMasternodeMetaMan::GetPlatformBan(const uint256& inv_hash) const
+{
+    LOCK(cs);
+    PlatformBanMessage ret;
+    if (!m_seen_platform_bans.get(inv_hash, ret)) {
+        return std::nullopt;
+    }
+
+    return ret;
+}
+
+void CMasternodeMetaMan::RememberPlatformBan(const uint256& inv_hash, PlatformBanMessage&& msg)
+{
+    LOCK(cs);
+    m_seen_platform_bans.insert(inv_hash, std::move(msg));
+}
+
 std::string MasternodeMetaStore::ToString() const
 {
     LOCK(cs);
     return strprintf("Masternodes: meta infos object count: %d, nDsqCount: %d", metaInfos.size(), nDsqCount);
 }
+
+uint256 PlatformBanMessage::GetHash() const { return ::SerializeHash(*this); }
diff --git a/src/masternode/meta.h b/src/masternode/meta.h
index 72eb844bb159..e06a10cceed9 100644
--- a/src/masternode/meta.h
+++ b/src/masternode/meta.h
@@ -5,14 +5,18 @@
 #ifndef BITCOIN_MASTERNODE_META_H
 #define BITCOIN_MASTERNODE_META_H
 
+#include <bls/bls.h>
+#include <saltedhasher.h>
 #include <serialize.h>
 #include <sync.h>
 #include <threadsafety.h>
 #include <uint256.h>
+#include <unordered_lru_cache.h>
 
 #include <atomic>
 #include <map>
 #include <memory>
+#include <optional>
 #include <vector>
 
 class CConnman;
@@ -46,6 +50,11 @@ class CMasternodeMetaInfo
     std::atomic<int64_t> lastOutboundAttempt{0};
     std::atomic<int64_t> lastOutboundSuccess{0};
 
+    //! bool flag is node currently under platform ban by p2p message
+    bool m_platform_ban GUARDED_BY(cs){false};
+    //! height at which platform ban has been applied or removed
+    int m_platform_ban_updated GUARDED_BY(cs){0};
+
 public:
     CMasternodeMetaInfo() = default;
     explicit CMasternodeMetaInfo(const uint256& _proTxHash) : proTxHash(_proTxHash) {}
@@ -55,22 +64,18 @@ class CMasternodeMetaInfo
         nMixingTxCount(ref.nMixingTxCount.load()),
         mapGovernanceObjectsVotedOn(ref.mapGovernanceObjectsVotedOn),
         lastOutboundAttempt(ref.lastOutboundAttempt.load()),
-        lastOutboundSuccess(ref.lastOutboundSuccess.load())
+        lastOutboundSuccess(ref.lastOutboundSuccess.load()),
+        m_platform_ban(ref.m_platform_ban),
+        m_platform_ban_updated(ref.m_platform_ban_updated)
     {
     }
 
     SERIALIZE_METHODS(CMasternodeMetaInfo, obj)
     {
         LOCK(obj.cs);
-        READWRITE(
-                obj.proTxHash,
-                obj.nLastDsq,
-                obj.nMixingTxCount,
-                obj.mapGovernanceObjectsVotedOn,
-                obj.outboundAttemptCount,
-                obj.lastOutboundAttempt,
-                obj.lastOutboundSuccess
-                );
+        READWRITE(obj.proTxHash, obj.nLastDsq, obj.nMixingTxCount, obj.mapGovernanceObjectsVotedOn,
+                  obj.outboundAttemptCount, obj.lastOutboundAttempt, obj.lastOutboundSuccess, obj.m_platform_ban,
+                  obj.m_platform_ban_updated);
     }
 
     UniValue ToJson() const;
@@ -96,6 +101,24 @@ class CMasternodeMetaInfo
     int64_t GetLastOutboundAttempt() const { return lastOutboundAttempt; }
     void SetLastOutboundSuccess(int64_t t) { lastOutboundSuccess = t; outboundAttemptCount = 0; }
     int64_t GetLastOutboundSuccess() const { return lastOutboundSuccess; }
+    bool SetPlatformBan(bool is_banned, int height)
+    {
+        LOCK(cs);
+        if (height < m_platform_ban_updated) {
+            return false;
+        }
+        if (height == m_platform_ban_updated && !is_banned) {
+            return false;
+        }
+        m_platform_ban = is_banned;
+        m_platform_ban_updated = height;
+        return true;
+    }
+    bool IsPlatformBanned() const
+    {
+        LOCK(cs);
+        return m_platform_ban;
+    }
 };
 using CMasternodeMetaInfoPtr = std::shared_ptr<CMasternodeMetaInfo>;
 
@@ -150,6 +173,41 @@ class MasternodeMetaStore
     std::string ToString() const;
 };
 
+/**
+ * Platform PoSe Ban are result in the node voting against the targeted evonode in all future DKG sessions until that targeted
+ *evonode has been successfully banned. Platform will initiate this ban process by passing relevant information to Core using RPC. See DIP-0031
+ *
+ * We use 2 main classes to manage Platform PoSe Ban
+ *
+ * PlatformBanMessage
+ * CMasternodeMetaInfo - a higher-level construct which store extra (non-deterministic) information about masternodes including platform ban status
+ **/
+
+/**
+ * PlatformBanMessage - low-level constructs which present p2p message PlatformBan containing the protx hash, requested
+ * height to ban, and BLS data: quorum hash and bls signature
+ */
+class PlatformBanMessage
+{
+public:
+    uint256 m_protx_hash;
+    int32_t m_requested_height{0};
+    uint256 m_quorum_hash;
+    CBLSSignature m_signature;
+
+    PlatformBanMessage() = default;
+
+    SERIALIZE_METHODS(PlatformBanMessage, obj)
+    {
+        READWRITE(obj.m_protx_hash, obj.m_requested_height, obj.m_quorum_hash);
+        if (!(s.GetType() & SER_GETHASH)) {
+            READWRITE(CBLSSignatureVersionWrapper(const_cast<CBLSSignature&>(obj.m_signature), false));
+        }
+    }
+
+    uint256 GetHash() const;
+};
+
 class CMasternodeMetaMan : public MasternodeMetaStore
 {
 private:
@@ -161,6 +219,12 @@ class CMasternodeMetaMan : public MasternodeMetaStore
 
     std::vector<uint256> vecDirtyGovernanceObjectHashes GUARDED_BY(cs);
 
+    // equal to double of expected amount of all evo nodes, see DIP-0028
+    // it consumes no more than 1Mb of RAM but will cover extreme cases
+    static constexpr size_t SeenBanInventorySize = 900;
+    mutable unordered_lru_cache<uint256, PlatformBanMessage, StaticSaltedHasher> m_seen_platform_bans GUARDED_BY(cs){
+        SeenBanInventorySize};
+
 public:
     explicit CMasternodeMetaMan();
     ~CMasternodeMetaMan();
@@ -181,6 +245,10 @@ class CMasternodeMetaMan : public MasternodeMetaStore
     void RemoveGovernanceObject(const uint256& nGovernanceObjectHash);
 
     std::vector<uint256> GetAndClearDirtyGovernanceObjectHashes();
+
+    bool AlreadyHavePlatformBan(const uint256& inv_hash) const;
+    std::optional<PlatformBanMessage> GetPlatformBan(const uint256& inv_hash) const;
+    void RememberPlatformBan(const uint256& inv_hash, PlatformBanMessage&& msg);
 };
 
 #endif // BITCOIN_MASTERNODE_META_H
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 8f64d634a3b5..f98ba7bfdeb8 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -37,6 +37,7 @@
 #include <util/check.h>
 #include <util/system.h>
 #include <util/strencodings.h>
+#include <util/underlying.h>
 #include <util/trace.h>
 
 #include <algorithm>
@@ -735,6 +736,9 @@ class PeerManagerImpl final : public PeerManager
                                const std::vector<CBlockHeader>& headers,
                                bool via_compact_block)
         EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, g_msgproc_mutex);
+    [[nodiscard]] MessageProcessingResult ProcessPlatformBanMessage(NodeId node, std::string_view msg_type, CDataStream& vRecv)
+        EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex, g_msgproc_mutex);
+
     /** Various helpers for headers processing, invoked by ProcessHeadersMessage() */
     /** Deal with state tracking and headers sync for peers that send the
      * occasional non-connecting header (this can happen due to BIP 130 headers
@@ -2281,6 +2285,8 @@ bool PeerManagerImpl::AlreadyHave(const CInv& inv)
                 (m_cj_ctx->queueman && m_cj_ctx->queueman->HasQueue(inv.hash)) ||
 #endif // ENABLE_WALLET
                 (m_active_ctx && m_active_ctx->cj_server->HasQueue(inv.hash));
+    case MSG_PLATFORM_BAN:
+        return m_mn_metaman.AlreadyHavePlatformBan(inv.hash);
     }
 
 
@@ -2894,6 +2900,13 @@ void PeerManagerImpl::ProcessGetData(CNode& pfrom, Peer& peer, const std::atomic
                 push = true;
             }
         }
+        if (!push && inv.type == MSG_PLATFORM_BAN) {
+            auto opt_platform_ban = m_mn_metaman.GetPlatformBan(inv.hash);
+            if (opt_platform_ban.has_value()) {
+                m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::PLATFORMBAN, *opt_platform_ban));
+                push = true;
+            }
+        }
 
         if (!push) {
             vNotFound.push_back(inv);
@@ -3524,6 +3537,83 @@ void PeerManagerImpl::PostProcessMessage(MessageProcessingResult&& result, NodeI
     }
 }
 
+MessageProcessingResult PeerManagerImpl::ProcessPlatformBanMessage(NodeId node, std::string_view msg_type, CDataStream& vRecv)
+{
+    if (msg_type != NetMsgType::PLATFORMBAN) return {};
+
+    // Do nothing if node is out of sync
+    if (!m_mn_sync.IsBlockchainSynced()) {
+        return {};
+    }
+
+    PlatformBanMessage ban_msg;
+    vRecv >> ban_msg;
+
+    const uint256 hash = ban_msg.GetHash();
+
+    LogPrintf("PLATFORMBAN -- hash: %s protx_hash: %s height: %d peer=%d\n", hash.ToString(), ban_msg.m_protx_hash.ToString(), ban_msg.m_requested_height, node);
+
+    MessageProcessingResult ret{};
+    ret.m_to_erase = CInv{MSG_PLATFORM_BAN, hash};
+
+    const auto list = Assert(m_dmnman)->GetListAtChainTip();
+    auto dmn = list.GetMN(ban_msg.m_protx_hash);
+    if (!dmn) {
+        // small P2P penalty (1), as the evonode may have very recently been removed
+        ret.m_error = MisbehavingError{1};
+        return ret;
+    }
+    if (dmn->nType != MnType::Evo) {
+        // Ban node, P2P penalty (100) if protx_hash is associated with a regular node not an evonode
+        LogPrintf("PLATFORMBAN -- hash: %s protx_hash: %s unexpected type of node\n", hash.ToString(), ban_msg.m_protx_hash.ToString());
+        ret.m_error = MisbehavingError{100};
+        return ret;
+    }
+    static constexpr int PLATFORM_BAN_WINDOW_BLOCKS = 576;
+    int tipHeight = WITH_LOCK(cs_main, return m_chainman.ActiveChainstate().m_chain.Height());
+    if (tipHeight < ban_msg.m_requested_height || tipHeight - PLATFORM_BAN_WINDOW_BLOCKS > ban_msg.m_requested_height) {
+        // m_requested_height is inside the range [TipHeight - PLATFORM_BAN_WINDOW_BLOCKS - 5, TipHeight + 5]
+        LogPrintf("PLATFORMBAN -- hash: %s protx_hash: %s unexpected height: %d tip: %d\n", hash.ToString(), ban_msg.m_protx_hash.ToString(), ban_msg.m_requested_height, tipHeight);
+        if (tipHeight + 5 < ban_msg.m_requested_height || tipHeight - PLATFORM_BAN_WINDOW_BLOCKS - 5 > ban_msg.m_requested_height) {
+            // m_requested_height is outside the range [TipHeight - PLATFORM_BAN_WINDOW_BLOCKS - 5, TipHeight + 5]
+            ret.m_error = MisbehavingError{10};
+            return ret;
+        }
+        ret.m_error = MisbehavingError{1};
+        return ret;
+    }
+
+    Consensus::LLMQType llmq_type = Params().GetConsensus().llmqTypePlatform;
+    auto quorum = m_llmq_ctx->qman->GetQuorum(llmq_type, ban_msg.m_quorum_hash);
+    if (!quorum) {
+        LogPrintf("PLATFORMBAN -- hash: %s protx_hash: %s missing quorum_hash: %s llmq_type: %d\n", hash.ToString(), ban_msg.m_protx_hash.ToString(), ban_msg.m_quorum_hash.ToString(), ToUnderlying(llmq_type));
+        ret.m_error = MisbehavingError{100};
+        return ret;
+    }
+
+    const std::string PLATFORM_BAN_REQUESTID_PREFIX = "PlatformPoSeBan";
+    const auto data = std::make_pair(ban_msg.m_protx_hash, ban_msg.m_requested_height);
+    const uint256 request_id = ::SerializeHash(std::make_pair(PLATFORM_BAN_REQUESTID_PREFIX, data));
+    const uint256 msg_hash = ::SerializeHash(data);
+
+    uint256 signHash = llmq::BuildSignHash(llmq_type, quorum->qc->quorumHash, request_id, msg_hash);
+
+    if (!ban_msg.m_signature.VerifyInsecure(quorum->qc->quorumPublicKey, signHash)) {
+        LogPrintf("PLATFORMBAN -- hash: %s protx_hash: %s request_id: %s msg_hash: %s sig validation failed\n", hash.ToString(), ban_msg.m_protx_hash.ToString(), request_id.ToString(), msg_hash.ToString());
+        ret.m_error = MisbehavingError{100};
+        return ret;
+    }
+
+    // At this point, the outgoing message serialization version can't change.
+    const auto meta_info = m_mn_metaman.GetMetaInfo(ban_msg.m_protx_hash);
+    if (meta_info->SetPlatformBan(true, ban_msg.m_requested_height)) {
+        LogPrintf("PLATFORMBAN -- forward message to other nodes\n");
+        m_mn_metaman.RememberPlatformBan(hash, std::move(ban_msg));
+        ret.m_inventory.emplace_back(MSG_PLATFORM_BAN, hash);
+    }
+    return ret;
+}
+
 void PeerManagerImpl::ProcessMessage(
     CNode& pfrom,
     const std::string& msg_type,
@@ -5234,7 +5324,6 @@ void PeerManagerImpl::ProcessMessage(
         Misbehaving(pfrom.GetId(), 100, strprintf("received not-requested quorumrotationinfo. peer=%d", pfrom.GetId()));
         return;
     }
-
     if (msg_type == NetMsgType::NOTFOUND) {
         // Remove the NOTFOUND transactions from the peer
         LOCK(cs_main);
@@ -5292,6 +5381,7 @@ void PeerManagerImpl::ProcessMessage(
         PostProcessMessage(m_llmq_ctx->qman->ProcessMessage(pfrom, m_connman, msg_type, vRecv), pfrom.GetId());
         m_llmq_ctx->shareman->ProcessMessage(pfrom, *this, m_sporkman, msg_type, vRecv);
         PostProcessMessage(m_llmq_ctx->sigman->ProcessMessage(pfrom.GetId(), msg_type, vRecv), pfrom.GetId());
+        PostProcessMessage(ProcessPlatformBanMessage(pfrom.GetId(), msg_type, vRecv), pfrom.GetId());
 
         if (msg_type == NetMsgType::CLSIG) {
             if (llmq::AreChainLocksEnabled(m_sporkman)) {
diff --git a/src/node/chainstate.cpp b/src/node/chainstate.cpp
index 6ee51872820e..555cef21a831 100644
--- a/src/node/chainstate.cpp
+++ b/src/node/chainstate.cpp
@@ -219,7 +219,7 @@ void DashChainstateSetup(ChainstateManager& chainman,
 {
     // Same logic as pblocktree
     dmnman.reset();
-    dmnman = std::make_unique<CDeterministicMNManager>(*evodb);
+    dmnman = std::make_unique<CDeterministicMNManager>(*evodb, mn_metaman);
 
     cpoolman.reset();
     cpoolman = std::make_unique<CCreditPoolManager>(*evodb);
diff --git a/src/protocol.cpp b/src/protocol.cpp
index 53c1f6b8a16e..c5683a16dc9d 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -90,6 +90,7 @@ MAKE_MSG(SENDHEADERS2, "sendheaders2");
 MAKE_MSG(HEADERS2, "headers2");
 MAKE_MSG(GETQUORUMROTATIONINFO, "getqrinfo");
 MAKE_MSG(QUORUMROTATIONINFO, "qrinfo");
+MAKE_MSG(PLATFORMBAN, "platformban");
 }; // namespace NetMsgType
 
 /** All known message types. Keep this in the same order as the list of
@@ -170,7 +171,8 @@ const static std::string allNetMessageTypes[] = {
     NetMsgType::SENDHEADERS2,
     NetMsgType::HEADERS2,
     NetMsgType::GETQUORUMROTATIONINFO,
-    NetMsgType::QUORUMROTATIONINFO
+    NetMsgType::QUORUMROTATIONINFO,
+    NetMsgType::PLATFORMBAN,
 };
 const static std::vector<std::string> allNetMessageTypesVec(std::begin(allNetMessageTypes), std::end(allNetMessageTypes));
 
@@ -190,6 +192,7 @@ const static std::string netMessageTypesViolateBlocksOnly[] = {
     NetMsgType::DSTX,
     NetMsgType::DSVIN,
     NetMsgType::GETQUORUMROTATIONINFO,
+    NetMsgType::PLATFORMBAN,
     NetMsgType::QBSIGSHARES,
     NetMsgType::QCOMPLAINT,
     NetMsgType::QCONTRIB,
@@ -296,6 +299,7 @@ const char* CInv::GetCommandInternal() const
         case MSG_CLSIG:                         return NetMsgType::CLSIG;
         case MSG_ISDLOCK:                       return NetMsgType::ISDLOCK;
         case MSG_DSQ:                           return NetMsgType::DSQUEUE;
+        case MSG_PLATFORM_BAN:                  return NetMsgType::PLATFORMBAN;
         default:
             return nullptr;
     }
diff --git a/src/protocol.h b/src/protocol.h
index d7fc41f11598..75456d161fb7 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -298,6 +298,7 @@ extern const char* SENDHEADERS2;
 extern const char* HEADERS2;
 extern const char* GETQUORUMROTATIONINFO;
 extern const char* QUORUMROTATIONINFO;
+extern const char* PLATFORMBAN;
 };
 
 /* Get a vector of all valid message types (see above) */
@@ -524,6 +525,7 @@ enum GetDataMsg : uint32_t {
     /* MSG_ISLOCK = 30, */                            // Non-deterministic InstantSend and not used anymore
     MSG_ISDLOCK = 31,
     MSG_DSQ = 32,
+    MSG_PLATFORM_BAN = 33,                            // Platform service ban (DIP-0031)
 };
 
 /** inv message data */
diff --git a/src/version.h b/src/version.h
index 025c3ea7beb6..4364d77b6400 100644
--- a/src/version.h
+++ b/src/version.h
@@ -11,7 +11,7 @@
  */
 
 
-static const int PROTOCOL_VERSION = 70237;
+static const int PROTOCOL_VERSION = 70238;
 
 //! initial proto version, to be increased after version/verack negotiation
 static const int INIT_PROTO_VERSION = 209;
@@ -20,7 +20,7 @@ static const int INIT_PROTO_VERSION = 209;
 static const int MIN_PEER_PROTO_VERSION = 70216;
 
 //! minimum proto version of masternode to accept in DKGs
-static const int MIN_MASTERNODE_PROTO_VERSION = 70237;
+static const int MIN_MASTERNODE_PROTO_VERSION = 70238;
 
 //! protocol version is included in MNAUTH starting with this version
 static const int MNAUTH_NODE_VER_VERSION = 70218;
@@ -64,9 +64,13 @@ static const int INCREASE_MAX_HEADERS2_VERSION = 70235;
 //! Behavior of QRINFO is changed in this protocol version
 static const int EFFICIENT_QRINFO_VERSION = 70236;
 
+
 //! cycleHash in isdlock message switched to using quorum's base block in this version
 static const int ISDLOCK_CYCLEHASH_UPDATE_VERSION = 70237;
 
+//! Introduced new p2p message platform pose BAN
+static const int PLATFORM_BAN_VERSION = 70238;
+
 // Make sure that none of the values above collide with `ADDRV2_FORMAT`.
 
 #endif // BITCOIN_VERSION_H
diff --git a/test/functional/p2p_platform_ban.py b/test/functional/p2p_platform_ban.py
new file mode 100755
index 000000000000..cb9cb362dbf1
--- /dev/null
+++ b/test/functional/p2p_platform_ban.py
@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025 The Dash Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+from test_framework.messages import msg_platformban, hash256, ser_string, ser_uint256
+from test_framework.p2p import (
+    p2p_lock,
+    P2PInterface,
+)
+from test_framework.test_framework import DashTestFramework
+from test_framework.util import wait_until_helper
+
+import struct
+
+class PlatformBanInterface(P2PInterface):
+    def __init__(self):
+        super().__init__()
+
+
+class PlatformBanMessagesTest(DashTestFramework):
+    def set_test_params(self):
+        self.set_dash_test_params(1, 0, [[]], evo_count=3)
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def check_banned(self, mn):
+        info = self.nodes[0].protx('info', mn.proTxHash)
+        return info['state']['PoSeBanHeight'] != -1
+
+    def run_test(self):
+        node = self.nodes[0]
+
+        node.sporkupdate("SPORK_17_QUORUM_DKG_ENABLED", 0)
+        node.sporkupdate("SPORK_23_QUORUM_POSE", 0)
+        self.wait_for_sporks_same()
+
+        evo_info_0 = self.dynamically_add_masternode(evo=True)
+        for _ in range(2):
+            self.dynamically_add_masternode(evo=True)
+
+        self.mempool_size = 0
+
+        self.mine_quorum(llmq_type_name='llmq_test_platform', llmq_type=106)
+
+        self.log.info("Create and sign platform-ban message for mn-0")
+        msg = msg_platformban()
+        msg.protx_hash = int(self.mninfo[0].proTxHash, 16)
+        msg.requested_height = node.getblockcount()
+
+        request_id_buf = ser_string(b"PlatformPoSeBan") + ser_uint256(msg.protx_hash) + struct.pack("<I", msg.requested_height)
+        request_id = hash256(request_id_buf)[::-1].hex()
+
+        quorum_hash = self.mninfo[1].get_node(self).quorum("selectquorum", 106, request_id)["quorumHash"]
+        msg.quorum_hash = int(quorum_hash, 16)
+
+        msg_hash = format(msg.calc_sha256(), '064x')
+
+        recsig = self.get_recovered_sig(request_id, msg_hash, llmq_type=106, use_platformsign=True)
+        msg.sig = bytearray.fromhex(recsig["sig"])
+
+        self.log.info("Platform ban message is created and signed")
+        p2p_node2 = self.mninfo[2].get_node(self).add_p2p_connection(PlatformBanInterface())
+        p2p_node2.send_message(msg)
+        wait_until_helper(lambda: p2p_node2.message_count["platformban"] > 0, timeout=10, lock=p2p_lock)
+        p2p_node2.message_count["platformban"] = 0
+
+        assert not self.check_banned(self.mninfo[0])
+
+        mninfos_valid = self.mninfo.copy()[1:]
+        self.mine_quorum(llmq_type_name='llmq_test_platform', expected_members=2, expected_connections=1, expected_contributions=2, expected_commitments=2, llmq_type=106, mninfos_valid=mninfos_valid)
+
+        p2p_node = node.add_p2p_connection(PlatformBanInterface())
+        p2p_node.send_message(msg)
+        self.mine_quorum(llmq_type_name='llmq_test_platform', expected_members=2, expected_connections=1, expected_contributions=2, expected_commitments=2, llmq_type=106, mninfos_valid=mninfos_valid)
+        assert self.check_banned(self.mninfo[0])
+
+        self.dynamically_evo_update_service(evo_info_0)
+        assert not self.check_banned(self.mninfo[0])
+
+
+if __name__ == '__main__':
+    PlatformBanMessagesTest().main()
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index d55010faeed4..5bc74df2a07f 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -2379,6 +2379,41 @@ def __repr__(self):
                (self.nVersion, repr(self.inputs), self.txid, self.cycleHash)
 
 
+class msg_platformban:
+    __slots__ = ("protx_hash", "requested_height", "quorum_hash", "sig")
+    msgtype = b"platformban"
+
+    def __init__(self, protx_hash=0, requested_height=0, quorum_hash=0, sig=b'\x00' * 96):
+        self.protx_hash = protx_hash
+        self.requested_height = requested_height
+        self.quorum_hash = quorum_hash
+        self.sig = sig
+
+    def deserialize(self, f):
+        self.protx_hash = deser_uint256(f)
+        self.requested_height= struct.unpack("<I", f.read(4))[0]
+        self.quorum_hash = deser_uint256(f)
+        self.sig = f.read(96)
+
+    def serialize(self):
+        r = b""
+        r += ser_uint256(self.protx_hash)
+        r += struct.pack("<I", self.requested_height)
+        r += ser_uint256(self.quorum_hash)
+        r += self.sig
+        return r
+
+    def calc_sha256(self):
+        r = b""
+        r += ser_uint256(self.protx_hash)
+        r += struct.pack("<I", self.requested_height)
+        return uint256_from_str(hash256(r))
+
+    def __repr__(self):
+        return "msg_platformban(protx_hash=%064x requested_height=%d, quorum_hash=%064x)" % \
+               (self.protx_hash, self.requested_height, self.quorum_hash)
+
+
 class msg_qsigshare:
     __slots__ = ("sig_shares",)
     msgtype = b"qsigshare"
diff --git a/test/functional/test_framework/p2p.py b/test/functional/test_framework/p2p.py
index b56ef5ddc419..7b384f2c2df8 100755
--- a/test/functional/test_framework/p2p.py
+++ b/test/functional/test_framework/p2p.py
@@ -65,6 +65,7 @@
     msg_merkleblock,
     msg_notfound,
     msg_ping,
+    msg_platformban,
     msg_pong,
     msg_qdata,
     msg_qgetdata,
@@ -99,8 +100,8 @@
 # The minimum P2P version that this test framework supports
 MIN_P2P_VERSION_SUPPORTED = 60001
 # The P2P version that this test framework implements and sends in its `version` message
-# Version 70237 switched cycleHash in isdlock message to using quorum's base block
-P2P_VERSION = 70237
+# Version 70238 introduced platform PoSe ban (dip-0031)
+P2P_VERSION = 70238
 # The services that this test framework offers in its `version` message
 P2P_SERVICES = NODE_NETWORK | NODE_HEADERS_COMPRESSED
 # The P2P user agent string that this test framework sends in its `version` message
@@ -165,6 +166,7 @@
     b"mnauth": None,
     b"mnlistdiff": msg_mnlistdiff,
     b"notfound": msg_notfound,
+    b"platformban": msg_platformban,
     b"qbsigs": None,
     b"qcomplaint": None,
     b"qcontrib": None,
@@ -578,7 +580,6 @@ def on_cfcheckpt(self, message): pass
     def on_cfheaders(self, message): pass
     def on_cfilter(self, message): pass
     def on_cmpctblock(self, message): pass
-    def on_feefilter(self, message): pass
     def on_filteradd(self, message): pass
     def on_filterclear(self, message): pass
     def on_filterload(self, message): pass
@@ -617,6 +618,7 @@ def on_clsig(self, message): pass
     def on_islock(self, message): pass
     def on_isdlock(self, message): pass
 
+    def on_platformban(self, message): pass
     def on_qgetdata(self, message): pass
     def on_qdata(self, message): pass
     def on_qwatch(self, message): pass
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 89e9893a23a6..2c1a8597f535 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -146,6 +146,7 @@
     'rpc_verifyislock.py',
     'feature_notifications.py',
     # vv Tests less than 60s vv
+    'p2p_platform_ban.py', # NOTE: needs dash_hash to pass
     'p2p_sendheaders.py', # NOTE: needs dash_hash to pass
     'p2p_sendheaders_compressed.py', # NOTE: needs dash_hash to pass
     'wallet_importmulti.py --legacy-wallet',