diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index cba0bdc55534..2e391388f55b 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -26,7 +26,7 @@ using node::BlockManager;
 /**
  * Asset Lock Transaction
  */
-bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state)
+bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state, bool is_v24_active)
 {
     if (tx.nType != TRANSACTION_ASSET_LOCK) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-type");
@@ -56,6 +56,9 @@ bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state)
     if (opt_assetLockTx->getVersion() == 0 || opt_assetLockTx->getVersion() > CAssetLockPayload::CURRENT_VERSION) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-version");
     }
+    if (!is_v24_active && opt_assetLockTx->getVersion() == CAssetLockPayload::CURRENT_VERSION) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-version-2");
+    }
 
     if (opt_assetLockTx->getCreditOutputs().empty()) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-emptycreditoutputs");
@@ -68,8 +71,14 @@ bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state)
         }
 
         creditOutputsAmount += out.nValue;
-        if (!out.scriptPubKey.IsPayToPublicKeyHash()) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-pubKeyHash");
+        if (opt_assetLockTx->getVersion() >= 2) {
+            if (!out.scriptPubKey.IsPayToPublicKeyHash() && !out.scriptPubKey.IsPayToScriptHash()) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-script-pubkey");
+            }
+        } else {
+            if (!out.scriptPubKey.IsPayToPublicKeyHash()) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetlocktx-pubKeyHash");
+            }
         }
     }
     if (creditOutputsAmount != returnAmount) {
diff --git a/src/evo/assetlocktx.h b/src/evo/assetlocktx.h
index 6a00f605f2c0..09462734e1e4 100644
--- a/src/evo/assetlocktx.h
+++ b/src/evo/assetlocktx.h
@@ -28,7 +28,8 @@ class BlockManager;
 class CAssetLockPayload
 {
 public:
-    static constexpr uint8_t CURRENT_VERSION = 1;
+    static constexpr uint8_t INITIAL_VERSION = 1;
+    static constexpr uint8_t CURRENT_VERSION = 2;
     static constexpr auto SPECIALTX_TYPE = TRANSACTION_ASSET_LOCK;
 
 private:
@@ -36,8 +37,8 @@ class CAssetLockPayload
     std::vector<CTxOut> creditOutputs;
 
 public:
-    explicit CAssetLockPayload(const std::vector<CTxOut>& creditOutputs) :
-        creditOutputs(creditOutputs)
+    explicit CAssetLockPayload(const std::vector<CTxOut>& creditOutputs, uint8_t nVersion = CURRENT_VERSION) :
+        nVersion(nVersion), creditOutputs(creditOutputs)
     {}
 
     CAssetLockPayload() = default;
@@ -154,7 +155,7 @@ class CAssetUnlockPayload
     }
 };
 
-bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state);
+bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state, bool is_v24_active = false);
 bool CheckAssetUnlockTx(const node::BlockManager& blockman, const llmq::CQuorumManager& qman, const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, const std::optional<CRangesSet>& indexes, TxValidationState& state);
 bool GetAssetUnlockFee(const CTransaction& tx, CAmount& txfee, TxValidationState& state);
 
diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index 1ccfc998840b..1f019b1cfecb 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -16,7 +16,9 @@
 #include <util/std23.h>
 
 #include <core_io.h>
+#include <key_io.h>
 #include <rpc/util.h>
+#include <script/standard.h>
 #include <util/check.h>
 
 #include <univalue.h>
@@ -98,7 +100,9 @@ RPCResult CAssetLockPayload::GetJsonHelp(const std::string& key, bool optional)
                     {RPCResult::Type::STR, "asm", "The asm"},
                     {RPCResult::Type::STR_HEX, "hex", "The hex"},
                     {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"},
-        }}}}}}
+                }},
+                {RPCResult::Type::STR, "address", /*optional=*/true, "DIP-18 Platform address (version >= 2 only)"},
+        }}}}
     }};
 }
 
@@ -112,6 +116,16 @@ UniValue CAssetLockPayload::ToJson() const
         UniValue spk(UniValue::VOBJ);
         ScriptToUniv(credit_output.scriptPubKey, spk, /*include_hex=*/true, /*include_address=*/false);
         out.pushKV("scriptPubKey", spk);
+        if (nVersion >= 2) {
+            CTxDestination dest;
+            if (ExtractDestination(credit_output.scriptPubKey, dest)) {
+                if (const auto* pkh = std::get_if<PKHash>(&dest)) {
+                    out.pushKV("address", EncodePlatformDestination(PlatformP2PKHDestination(uint160(*pkh))));
+                } else if (const auto* sh = std::get_if<ScriptHash>(&dest)) {
+                    out.pushKV("address", EncodePlatformDestination(PlatformP2SHDestination(uint160(*sh))));
+                }
+            }
+        }
         outputs.push_back(out);
     }
 
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 65b1e6c4e2c6..bf6521585ee6 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -138,7 +138,7 @@ static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, llmq::CQuorumSn
         case TRANSACTION_MNHF_SIGNAL:
             return CheckMNHFTx(chainman, qman, tx, pindexPrev, state);
         case TRANSACTION_ASSET_LOCK:
-            return CheckAssetLockTx(tx, state);
+            return CheckAssetLockTx(tx, state, DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24));
         case TRANSACTION_ASSET_UNLOCK:
             return CheckAssetUnlockTx(chainman.m_blockman, qman, tx, pindexPrev, indexes, state);
         }
diff --git a/src/rpc/output_script.cpp b/src/rpc/output_script.cpp
index 2ad98f709d38..61ed5f486913 100644
--- a/src/rpc/output_script.cpp
+++ b/src/rpc/output_script.cpp
@@ -35,6 +35,7 @@ static RPCHelpMan validateaddress()
             RPCResult::Type::OBJ, "", "",
             {
                 {RPCResult::Type::BOOL, "isvalid", "If the address is valid or not"},
+                {RPCResult::Type::BOOL, "isplatform", /*optional=*/true, "If the address is a DIP-18 Dash Platform address"},
                 {RPCResult::Type::STR, "address", /*optional=*/true, "The Dash address validated"},
                 {RPCResult::Type::STR_HEX, "scriptPubKey", /*optional=*/true, "The hex-encoded scriptPubKey generated by the address"},
                 {RPCResult::Type::BOOL, "isscript", /*optional=*/true, "If the key is a script"},
@@ -47,16 +48,15 @@ static RPCHelpMan validateaddress()
         },
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
         {
+            const std::string address = request.params[0].get_str();
             std::string error_msg;
-            CTxDestination dest = DecodeDestination(request.params[0].get_str(), error_msg);
+            CTxDestination dest = DecodeDestination(address, error_msg);
             const bool isValid = IsValidDestination(dest);
-            CHECK_NONFATAL(isValid == error_msg.empty());
 
             UniValue ret(UniValue::VOBJ);
-            ret.pushKV("isvalid", isValid);
             if (isValid) {
-                std::string currentAddress = EncodeDestination(dest);
-                ret.pushKV("address", currentAddress);
+                ret.pushKV("isvalid", true);
+                ret.pushKV("address", EncodeDestination(dest));
 
                 CScript scriptPubKey = GetScriptForDestination(dest);
                 ret.pushKV("scriptPubKey", HexStr(scriptPubKey));
@@ -64,7 +64,16 @@ static RPCHelpMan validateaddress()
                 UniValue detail = DescribeAddress(dest);
                 ret.pushKVs(detail);
             } else {
-                ret.pushKV("error", error_msg);
+                std::string platform_error;
+                PlatformDestination platform_dest = DecodePlatformDestination(address, platform_error);
+                if (IsValidPlatformDestination(platform_dest)) {
+                    ret.pushKV("isvalid", true);
+                    ret.pushKV("isplatform", true);
+                    ret.pushKV("address", EncodePlatformDestination(platform_dest));
+                } else {
+                    ret.pushKV("isvalid", false);
+                    ret.pushKV("error", error_msg);
+                }
             }
 
             return ret;
diff --git a/src/test/evo_assetlocks_tests.cpp b/src/test/evo_assetlocks_tests.cpp
index d21e8df73a03..f0be30a15b08 100644
--- a/src/test/evo_assetlocks_tests.cpp
+++ b/src/test/evo_assetlocks_tests.cpp
@@ -70,7 +70,7 @@ static CMutableTransaction CreateAssetLockTx(FillableSigningProvider& keystore,
     creditOutputs[1].nValue = 13 * CENT;
     creditOutputs[1].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
 
-    CAssetLockPayload assetLockTx(creditOutputs);
+    CAssetLockPayload assetLockTx(creditOutputs, CAssetLockPayload::INITIAL_VERSION);
 
     CMutableTransaction tx;
     tx.nVersion = 3;
@@ -124,9 +124,8 @@ static CMutableTransaction CreateAssetUnlockTx(FillableSigningProvider& keystore
 
 BOOST_FIXTURE_TEST_SUITE(evo_assetlocks_tests, TestChain100Setup)
 
-BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
+static void CheckAssetLockCommon(uint8_t version, bool is_v24_active)
 {
-
     LOCK(cs_main);
     FillableSigningProvider keystore;
     CCoinsView coinsDummy;
@@ -135,7 +134,13 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
     CKey key;
     key.MakeNewKey(true);
 
-    const CTransaction tx{CreateAssetLockTx(keystore, coins, key)};
+    CMutableTransaction baseTx = CreateAssetLockTx(keystore, coins, key);
+    const auto basePayload = GetTxPayload<CAssetLockPayload>(CTransaction(baseTx));
+    const std::vector<CTxOut> creditOutputs = basePayload->getCreditOutputs();
+
+    SetTxPayload(baseTx, CAssetLockPayload(creditOutputs, version));
+
+    const CTransaction tx{baseTx};
     std::string reason;
     BOOST_CHECK(IsStandardTx(CTransaction(tx), reason));
 
@@ -144,7 +149,7 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
     BOOST_CHECK_MESSAGE(CheckTransaction(CTransaction(tx), tx_state), strTest);
     BOOST_CHECK(tx_state.IsValid());
 
-    BOOST_CHECK(CheckAssetLockTx(CTransaction(tx), tx_state));
+    BOOST_CHECK(CheckAssetLockTx(CTransaction(tx), tx_state, is_v24_active));
 
     BOOST_CHECK(AreInputsStandard(CTransaction(tx), coins));
 
@@ -155,14 +160,14 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
         const auto opt_payload = GetTxPayload<CAssetLockPayload>(tx);
 
         BOOST_CHECK(opt_payload.has_value());
-        BOOST_CHECK(opt_payload->getVersion() == 1);
+        BOOST_CHECK(opt_payload->getVersion() == version);
     }
 
     {
         // Wrong type "Asset Unlock TX" instead "Asset Lock TX"
         CMutableTransaction txWrongType(tx);
         txWrongType.nType = TRANSACTION_ASSET_UNLOCK;
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txWrongType), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txWrongType), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-type");
     }
 
@@ -176,40 +181,35 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
         BOOST_CHECK(inSum == outSum);
 
         // Outputs should not be bigger than inputs
-        CMutableTransaction txBigOutput(tx);
+        CMutableTransaction txBigOutput(baseTx);
         txBigOutput.vout[0].nValue += 1;
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txBigOutput), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txBigOutput), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-creditamount");
 
         // Smaller outputs are allown
-        CMutableTransaction txSmallOutput(tx);
+        CMutableTransaction txSmallOutput(baseTx);
         txSmallOutput.vout[1].nValue -= 1;
-        BOOST_CHECK(CheckAssetLockTx(CTransaction(txSmallOutput), tx_state));
+        BOOST_CHECK(CheckAssetLockTx(CTransaction(txSmallOutput), tx_state, is_v24_active));
     }
 
-    const auto assetLockPayload = GetTxPayload<CAssetLockPayload>(tx);
-    const std::vector<CTxOut> creditOutputs = assetLockPayload->getCreditOutputs();
-
     {
         // Sum of credit output greater than OP_RETURN
         std::vector<CTxOut> wrongOutput = creditOutputs;
         wrongOutput[0].nValue += CENT;
-        CAssetLockPayload greaterCreditsPayload(wrongOutput);
 
-        CMutableTransaction txGreaterCredits(tx);
-        SetTxPayload(txGreaterCredits, greaterCreditsPayload);
+        CMutableTransaction txGreaterCredits(baseTx);
+        SetTxPayload(txGreaterCredits, CAssetLockPayload(wrongOutput, version));
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txGreaterCredits), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txGreaterCredits), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-creditamount");
 
         // Sum of credit output less than OP_RETURN
         wrongOutput[1].nValue -= 2 * CENT;
-        CAssetLockPayload lessCreditsPayload(wrongOutput);
 
-        CMutableTransaction txLessCredits(tx);
-        SetTxPayload(txLessCredits, lessCreditsPayload);
+        CMutableTransaction txLessCredits(baseTx);
+        SetTxPayload(txLessCredits, CAssetLockPayload(wrongOutput, version));
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txLessCredits), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txLessCredits), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-creditamount");
     }
 
@@ -217,24 +217,23 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
         // Credit output is out-of-range
         std::vector<CTxOut> creditOutputsOutOfRange = creditOutputs;
         creditOutputsOutOfRange[0].nValue = 0;
-        CAssetLockPayload invalidOutputsPayload(creditOutputsOutOfRange);
 
-        CMutableTransaction txInvalidOutputs(tx);
-        SetTxPayload(txInvalidOutputs, invalidOutputsPayload);
+        CMutableTransaction txInvalidOutputs(baseTx);
+        SetTxPayload(txInvalidOutputs, CAssetLockPayload(creditOutputsOutOfRange, version));
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txInvalidOutputs), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txInvalidOutputs), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-credit-outofrange");
 
         // one of output is out of range
         creditOutputsOutOfRange[0].nValue = MAX_MONEY + 1;
-        SetTxPayload(txInvalidOutputs, CAssetLockPayload{creditOutputsOutOfRange});
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txInvalidOutputs), tx_state));
+        SetTxPayload(txInvalidOutputs, CAssetLockPayload(creditOutputsOutOfRange, version));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txInvalidOutputs), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-credit-outofrange");
 
         // sum of some of output is out of range
         creditOutputsOutOfRange[0].nValue = MAX_MONEY + 1 - creditOutputsOutOfRange[1].nValue;
-        SetTxPayload(txInvalidOutputs, CAssetLockPayload{creditOutputsOutOfRange});
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txInvalidOutputs), tx_state));
+        SetTxPayload(txInvalidOutputs, CAssetLockPayload(creditOutputsOutOfRange, version));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txInvalidOutputs), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-credit-outofrange");
 
     }
@@ -242,60 +241,160 @@ BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
         // One credit output keys is not pub key
         std::vector<CTxOut> creditOutputsNotPubkey = creditOutputs;
         creditOutputsNotPubkey[0].scriptPubKey = CScript() << OP_1;
-        CAssetLockPayload notPubkeyPayload(creditOutputsNotPubkey);
 
-        CMutableTransaction txNotPubkey(tx);
-        SetTxPayload(txNotPubkey, notPubkeyPayload);
+        CMutableTransaction txNotPubkey(baseTx);
+        SetTxPayload(txNotPubkey, CAssetLockPayload(creditOutputsNotPubkey, version));
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txNotPubkey), tx_state));
-        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-pubKeyHash");
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txNotPubkey), tx_state, is_v24_active));
+        if (version >= 2) {
+            BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-script-pubkey");
+        } else {
+            BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-pubKeyHash");
+        }
 
     }
 
     {
         // OP_RETURN must be only one, not more
-        CMutableTransaction txMultipleReturn(tx);
+        CMutableTransaction txMultipleReturn(baseTx);
         txMultipleReturn.vout[1].scriptPubKey = CScript() << OP_RETURN << ParseHex("");
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txMultipleReturn), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txMultipleReturn), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-multiple-return");
 
     }
 
     {
         // zero/negative OP_RETURN
-        CMutableTransaction txReturnOutOfRange(tx);
+        CMutableTransaction txReturnOutOfRange(baseTx);
         txReturnOutOfRange.vout[0].nValue = 0;
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txReturnOutOfRange), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txReturnOutOfRange), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-opreturn-outofrange");
 
         txReturnOutOfRange.vout[0].nValue = MAX_MONEY + 1;
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txReturnOutOfRange), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txReturnOutOfRange), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-opreturn-outofrange");
     }
 
 
     {
         // OP_RETURN is missing
-        CMutableTransaction txNoReturn(tx);
+        CMutableTransaction txNoReturn(baseTx);
         txNoReturn.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txNoReturn), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txNoReturn), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-no-return");
     }
 
     {
         // OP_RETURN should not have any data
-        CMutableTransaction txReturnData(tx);
+        CMutableTransaction txReturnData(baseTx);
         txReturnData.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("abcd");
 
-        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txReturnData), tx_state));
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txReturnData), tx_state, is_v24_active));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-non-empty-return");
     }
 }
 
+BOOST_FIXTURE_TEST_CASE(evo_assetlock, TestChain100Setup)
+{
+    CheckAssetLockCommon(CAssetLockPayload::INITIAL_VERSION, /*is_v24_active=*/false);
+    CheckAssetLockCommon(CAssetLockPayload::INITIAL_VERSION, /*is_v24_active=*/true);
+    CheckAssetLockCommon(CAssetLockPayload::CURRENT_VERSION, /*is_v24_active=*/true);
+}
+
+BOOST_FIXTURE_TEST_CASE(evo_assetlock_v2, TestChain100Setup)
+{
+    LOCK(cs_main);
+    FillableSigningProvider keystore;
+    CCoinsView coinsDummy;
+    CCoinsViewCache coins(&coinsDummy);
+
+    CKey key;
+    key.MakeNewKey(true);
+
+    CMutableTransaction tx = CreateAssetLockTx(keystore, coins, key);
+    TxValidationState tx_state;
+
+    const auto v1Payload = GetTxPayload<CAssetLockPayload>(CTransaction(tx));
+    const std::vector<CTxOut> creditOutputs = v1Payload->getCreditOutputs();
+
+    // Build v2 payload with same P2PKH credit outputs
+    CAssetLockPayload v2Payload(creditOutputs);
+    BOOST_CHECK(v2Payload.getVersion() == CAssetLockPayload::CURRENT_VERSION);
+    SetTxPayload(tx, v2Payload);
+
+    {
+        // v2 P2PKH: accepted with is_v24_active=true
+        BOOST_CHECK(CheckAssetLockTx(CTransaction(tx), tx_state, /*is_v24_active=*/true));
+    }
+
+    {
+        // v2 P2PKH: rejected pre-v24
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(tx), tx_state, /*is_v24_active=*/false));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-version-2");
+    }
+
+    {
+        // v2 with P2SH credit output: accepted with is_v24_active=true
+        CScript p2sh_script = GetScriptForDestination(ScriptHash(CScript() << OP_1));
+        std::vector<CTxOut> p2shOutputs(1);
+        p2shOutputs[0].nValue = 30 * CENT;
+        p2shOutputs[0].scriptPubKey = p2sh_script;
+
+        CMutableTransaction txP2SH(tx);
+        SetTxPayload(txP2SH, CAssetLockPayload(p2shOutputs));
+
+        BOOST_CHECK(CheckAssetLockTx(CTransaction(txP2SH), tx_state, /*is_v24_active=*/true));
+    }
+
+    {
+        // v1 with P2SH credit output: rejected even post-v24
+        CScript p2sh_script = GetScriptForDestination(ScriptHash(CScript() << OP_1));
+        std::vector<CTxOut> p2shOutputs(1);
+        p2shOutputs[0].nValue = 30 * CENT;
+        p2shOutputs[0].scriptPubKey = p2sh_script;
+
+        CMutableTransaction txV1P2SH(tx);
+        SetTxPayload(txV1P2SH, CAssetLockPayload(p2shOutputs, CAssetLockPayload::INITIAL_VERSION));
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txV1P2SH), tx_state, /*is_v24_active=*/true));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-pubKeyHash");
+    }
+
+    {
+        // v2 with non-P2PKH/non-P2SH credit output: rejected
+        std::vector<CTxOut> badOutputs(1);
+        badOutputs[0].nValue = 30 * CENT;
+        badOutputs[0].scriptPubKey = CScript() << OP_1;
+
+        CMutableTransaction txBad(tx);
+        SetTxPayload(txBad, CAssetLockPayload(badOutputs));
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txBad), tx_state, /*is_v24_active=*/true));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-script-pubkey");
+    }
+
+    {
+        // v1 still works post-v24
+        CMutableTransaction txV1(tx);
+        SetTxPayload(txV1, CAssetLockPayload(creditOutputs, CAssetLockPayload::INITIAL_VERSION));
+
+        BOOST_CHECK(CheckAssetLockTx(CTransaction(txV1), tx_state, /*is_v24_active=*/true));
+    }
+
+    {
+        // version 3 (future): rejected even post-v24
+        CMutableTransaction txV3(tx);
+        SetTxPayload(txV3, CAssetLockPayload(creditOutputs, /*nVersion=*/3));
+
+        BOOST_CHECK(!CheckAssetLockTx(CTransaction(txV3), tx_state, /*is_v24_active=*/true));
+        BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetlocktx-version");
+    }
+}
+
 BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
 {
     LOCK(cs_main);
diff --git a/src/wallet/rpc/spend.cpp b/src/wallet/rpc/spend.cpp
index de9385e82b5d..97b0ac95f845 100644
--- a/src/wallet/rpc/spend.cpp
+++ b/src/wallet/rpc/spend.cpp
@@ -27,17 +27,36 @@ static void ParseRecipients(const UniValue& address_amounts, const UniValue& sub
     std::set<CTxDestination> destinations;
     int i = 0;
     for (const std::string& address: address_amounts.getKeys()) {
-        CTxDestination dest = DecodeDestination(address);
-        if (!IsValidDestination(dest)) {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Dash address: ") + address);
-        }
+        CScript script_pub_key;
+        bool is_platform = false;
 
-        if (destinations.count(dest)) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated address: ") + address);
+        CTxDestination dest = DecodeDestination(address);
+        if (IsValidDestination(dest)) {
+            if (destinations.count(dest)) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated address: ") + address);
+            }
+            destinations.insert(dest);
+            script_pub_key = GetScriptForDestination(dest);
+        } else {
+            std::string platform_error;
+            PlatformDestination platform_dest = DecodePlatformDestination(address, platform_error);
+            if (!IsValidPlatformDestination(platform_dest)) {
+                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Dash address: ") + address);
+            }
+            is_platform = true;
+            if (const auto* pkh = std::get_if<PlatformP2PKHDestination>(&platform_dest)) {
+                uint160 hash;
+                std::copy(pkh->begin(), pkh->end(), hash.begin());
+                script_pub_key = GetScriptForDestination(PKHash(hash));
+            } else if (const auto* sh = std::get_if<PlatformP2SHDestination>(&platform_dest)) {
+                uint160 hash;
+                std::copy(sh->begin(), sh->end(), hash.begin());
+                script_pub_key = GetScriptForDestination(ScriptHash(hash));
+            } else {
+                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Unsupported Platform address type: ") + address);
+            }
         }
-        destinations.insert(dest);
 
-        CScript script_pub_key = GetScriptForDestination(dest);
         CAmount amount = AmountFromValue(address_amounts[i++]);
 
         bool subtract_fee = false;
@@ -48,7 +67,7 @@ static void ParseRecipients(const UniValue& address_amounts, const UniValue& sub
             }
         }
 
-        CRecipient recipient = {script_pub_key, amount, subtract_fee};
+        CRecipient recipient = {script_pub_key, amount, subtract_fee, is_platform};
         recipients.push_back(recipient);
     }
 }
diff --git a/src/wallet/spend.cpp b/src/wallet/spend.cpp
index bfba61643130..94ea52f0f605 100644
--- a/src/wallet/spend.cpp
+++ b/src/wallet/spend.cpp
@@ -6,7 +6,9 @@
 #include <coinjoin/options.h>
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
+#include <evo/assetlocktx.h>
 #include <evo/dmn_types.h>
+#include <evo/specialtx.h>
 #include <interfaces/chain.h>
 #include <policy/policy.h>
 #include <script/signingprovider.h>
@@ -769,7 +771,7 @@ static void DiscourageFeeSniping(CMutableTransaction& tx, FastRandomContext& rng
 
 static util::Result<CreatedTransactionResult> CreateTransactionInternal(
         CWallet& wallet,
-        const std::vector<CRecipient>& vecSend,
+        const std::vector<CRecipient>& vecSend_in,
         int change_pos,
         const CCoinControl& coin_control,
         bool sign,
@@ -777,6 +779,36 @@ static util::Result<CreatedTransactionResult> CreateTransactionInternal(
 {
     AssertLockHeld(wallet.cs_wallet);
 
+    // DIP-27 v2: when platform recipients are present, build asset-lock payload
+    // and replace platform recipients with an OP_RETURN output.
+    std::optional<CAssetLockPayload> opt_assetLockPayload;
+    std::vector<CRecipient> vecSend;
+    const bool has_platform = std::any_of(vecSend_in.cbegin(), vecSend_in.cend(),
+                                           [](const auto& r) { return r.fPlatformTransfer; });
+    if (has_platform) {
+        std::vector<CTxOut> creditOutputs;
+        CAmount platform_total{0};
+
+        for (const auto& recipient : vecSend_in) {
+            if (recipient.fPlatformTransfer) {
+                creditOutputs.emplace_back(recipient.nAmount, recipient.scriptPubKey);
+                platform_total += recipient.nAmount;
+            } else {
+                vecSend.push_back(recipient);
+            }
+        }
+
+        opt_assetLockPayload.emplace(creditOutputs);
+        CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+        ss << *opt_assetLockPayload;
+        nExtraPayloadSize = ss.size();
+
+        vecSend.insert(vecSend.begin(),
+                       {CScript() << OP_RETURN << ParseHex(""), platform_total, /*fSubtractFeeFromAmount=*/false});
+    } else {
+        vecSend = vecSend_in;
+    }
+
     // out variables, to be packed into returned result structure
     CAmount nFeeRet;
     int nChangePosInOut = change_pos;
@@ -1056,6 +1088,12 @@ static util::Result<CreatedTransactionResult> CreateTransactionInternal(
         return util::Error{error};
     }
 
+    if (opt_assetLockPayload) {
+        txNew.nVersion = 3;
+        txNew.nType = TRANSACTION_ASSET_LOCK;
+        SetTxPayload(txNew, *opt_assetLockPayload);
+    }
+
     if (sign && !wallet.SignTransaction(txNew)) {
         return util::Error{_("Signing transaction failed")};
     }
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 6a0323990787..1f8471c0e9fd 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -260,6 +260,7 @@ struct CRecipient
     CScript scriptPubKey;
     CAmount nAmount;
     bool fSubtractFeeFromAmount;
+    bool fPlatformTransfer{false};
 };
 
 struct WalletTxHasher
diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index 709cc386e7b5..ea3b21a62bf0 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -29,6 +29,7 @@
 )
 from test_framework.script import (
     CScript,
+    hash160,
     OP_RETURN,
 )
 from test_framework.script_util import (
@@ -42,6 +43,7 @@
     assert_greater_than_or_equal,
     softfork_active,
 )
+from test_framework.segwit_addr import encode_platform_p2pkh
 from test_framework.wallet_util import bytes_to_wif
 
 llmq_type_test = 106 # LLMQType::LLMQ_TEST_PLATFORM
@@ -63,7 +65,7 @@ def set_test_params(self):
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
-    def create_assetlock(self, coin, amount, pubkey):
+    def create_assetlock(self, coin, amount, pubkey, version=1):
         node_wallet = self.nodes[0]
 
 
@@ -76,7 +78,7 @@ def create_assetlock(self, coin, amount, pubkey):
             credit_outputs.append(CTxOut(COIN, key_to_p2pkh_script(pubkey)))
         credit_outputs.append(CTxOut(tmp_amount, key_to_p2pkh_script(pubkey)))
 
-        lockTx_payload = CAssetLockTx(1, credit_outputs)
+        lockTx_payload = CAssetLockTx(version, credit_outputs)
 
         remaining = int(COIN * coin['amount']) - tiny_amount - amount
 
@@ -269,6 +271,7 @@ def run_test(self):
         self.test_withdrawal_limits(node_wallet, node, pubkey)
         self.test_mn_rr(node_wallet, node, pubkey)
         self.test_withdrawals_fork(node_wallet, node, pubkey)
+        self.test_asset_locks_v2_pre_v24(node_wallet, node, pubkey)
         self.test_v24_fork(node_wallet, node, pubkey)
 
 
@@ -706,8 +709,11 @@ def test_withdrawals_fork(self, node_wallet, node, pubkey):
     def test_v24_fork(self, node_wallet, node, pubkey):
         self.log.info("Testing asset unlock after 'v24' activation...")
         self.activate_by_name('v24', 750)
+        self.mempool_size = node_wallet.getmempoolinfo()['size']
         self.log.info(f'post-v24 height: {node.getblockcount()} credit: {self.get_credit_pool_balance()}')
 
+        self.test_asset_locks_v2(node_wallet, node, pubkey)
+
         index = 601
         while index < 611:
             self.log.info(f"Generating new Asset Unlock tx, index={index}...")
@@ -758,6 +764,69 @@ def test_v24_fork(self, node_wallet, node, pubkey):
         tip_hash = self.generate(node, 1)[0]
         assert txid_in_block not in node.getblock(tip_hash)['tx']
 
+    def test_asset_locks_v2_pre_v24(self, node_wallet, node, pubkey):
+        self.log.info("Testing asset lock v2 rejection before v24 activation...")
+        assert not softfork_active(node_wallet, 'v24')
+
+        self.mempool_size = node_wallet.getmempoolinfo()['size']
+
+        coins = node_wallet.listunspent(query_options={'minimumAmount': 1})
+        coin = coins.pop()
+        lock_tx = self.create_assetlock(coin, COIN, pubkey, version=2)
+        self.check_mempool_result(tx=lock_tx,
+            result_expected={'allowed': False, 'reject-reason': 'bad-assetlocktx-version-2'})
+        self.log.info("v2 asset lock correctly rejected pre-v24")
+
+    def test_asset_locks_v2(self, node_wallet, node, pubkey):
+        self.log.info("Testing asset lock v2 after v24 activation...")
+        assert softfork_active(node_wallet, 'v24')
+
+        locked = self.get_credit_pool_balance()
+
+        self.log.info("Test v2 mempool acceptance, sendtoaddress, v1 compat, validateaddress...")
+        coins = node_wallet.listunspent(query_options={'minimumAmount': 1})
+
+        # v2 via raw construction
+        lock_tx_v2 = self.create_assetlock(coins.pop(), COIN, pubkey, version=2)
+        self.check_mempool_result(tx=lock_tx_v2,
+            result_expected={'allowed': True, 'fees': {'base': Decimal(str(tiny_amount / COIN))}})
+        self.send_tx(lock_tx_v2)
+
+        # v2 via sendtoaddress (two different platform addresses)
+        platform_addr_from_key = encode_platform_p2pkh('tdash', hash160(pubkey))
+        txid1 = node_wallet.sendtoaddress(platform_addr_from_key, 1.0)
+
+        val = node_wallet.validateaddress(platform_addr_from_key)
+        assert_equal(val['isvalid'], True)
+        assert_equal(val['isplatform'], True)
+
+        # v1 still accepted post-v24
+        lock_tx_v1 = self.create_assetlock(coins.pop(), COIN, pubkey, version=1)
+        self.send_tx(lock_tx_v1)
+
+        # mine all at once
+        locked += node.getblocktemplate()['masternode'][0]['amount'] + 3 * COIN
+        self.generate(node, 1)
+        assert_equal(self.get_credit_pool_balance(), locked)
+
+        # verify v2 raw tx JSON
+        rpc_v2 = node.getrawtransaction(lock_tx_v2.rehash(), 1)
+        assert_equal(rpc_v2['assetLockTx']['version'], 2)
+        assert rpc_v2['assetLockTx']['creditOutputs'][0]['address'].startswith('tdash1')
+
+        # verify v2 sendtoaddress tx JSON
+        raw1 = node.getrawtransaction(txid1, 1)
+        assert_equal(raw1['type'], 8)
+        assert_equal(raw1['assetLockTx']['version'], 2)
+        assert_equal(raw1['assetLockTx']['creditOutputs'][0]['valueSat'], COIN)
+        assert_equal(raw1['assetLockTx']['creditOutputs'][0]['address'], platform_addr_from_key)
+        assert any(vout['scriptPubKey']['type'] == 'nulldata' and vout['valueSat'] == COIN for vout in raw1['vout'])
+
+        # verify v1 has no 'address' in JSON
+        rpc_v1 = node.getrawtransaction(lock_tx_v1.rehash(), 1)
+        assert_equal(rpc_v1['assetLockTx']['version'], 1)
+        assert 'address' not in rpc_v1['assetLockTx']['creditOutputs'][0]
+
 
 if __name__ == '__main__':
     AssetLocksTest().main()