diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index a2b4c418af..e3490d57f8 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -7,12 +7,13 @@
 
 #include <chainparamsseeds.h>
 #include <consensus/merkle.h>
+#include <crypto/sha256.h>
 #include <deploymentinfo.h>
 #include <hash.h> // for signet block challenge hash
 #include <issuance.h>
 #include <primitives/transaction.h>
+#include <util/moneystr.h>
 #include <util/system.h>
-#include <crypto/sha256.h>
 
 #include <assert.h>
 
@@ -232,6 +233,8 @@ class CMainParams : public CChainParams {
         multi_data_permitted = false;
         accept_discount_ct = false;
         create_discount_ct = false;
+        pegin_subsidy = PeginSubsidy();
+        pegin_minimum = PeginMinimum();
         consensus.has_parent_chain = false;
         g_signed_blocks = false;
         g_con_elementsmode = false;
@@ -379,6 +382,8 @@ class CTestNetParams : public CChainParams {
         multi_data_permitted = false;
         accept_discount_ct = false;
         create_discount_ct = false;
+        pegin_subsidy = PeginSubsidy();
+        pegin_minimum = PeginMinimum();
         consensus.has_parent_chain = false;
         g_signed_blocks = false;
         g_con_elementsmode = false;
@@ -544,6 +549,8 @@ class SigNetParams : public CChainParams {
         multi_data_permitted = false;
         accept_discount_ct = false;
         create_discount_ct = false;
+        pegin_subsidy = PeginSubsidy();
+        pegin_minimum = PeginMinimum();
         consensus.has_parent_chain = false;
         g_signed_blocks = false; // lol
         g_con_elementsmode = false;
@@ -648,6 +655,8 @@ class CRegTestParams : public CChainParams {
         multi_data_permitted = false;
         accept_discount_ct = false;
         create_discount_ct = false;
+        pegin_subsidy = PeginSubsidy();
+        pegin_minimum = PeginMinimum();
         consensus.has_parent_chain = false;
         g_signed_blocks = false;
         g_con_elementsmode = false;
@@ -792,6 +801,39 @@ void CRegTestParams::UpdateActivationParametersFromArgs(const ArgsManager& args)
     }
 }
 
+// ELEMENTS
+PeginSubsidy ParsePeginSubsidy(const ArgsManager& args) {
+    PeginSubsidy pegin_subsidy;
+
+    pegin_subsidy.height = args.GetIntArg("-peginsubsidyheight", std::numeric_limits<int>::max());
+    if (pegin_subsidy.height < 0) {
+        throw std::runtime_error(strprintf("Invalid block height (%d) for -peginsubsidyheight. Must be positive.", pegin_subsidy.height));
+    }
+    if (std::optional<CAmount> amount = ParseMoney(args.GetArg("-peginsubsidythreshold", "0"))) {
+        pegin_subsidy.threshold = amount.value();
+    } else {
+        throw std::runtime_error("Invalid -peginsubsidythreshold");
+    }
+
+    return pegin_subsidy;
+};
+
+PeginMinimum ParsePeginMinimum(const ArgsManager& args) {
+    PeginMinimum pegin_minimum;
+
+    pegin_minimum.height = args.GetIntArg("-peginminheight", std::numeric_limits<int>::max());
+    if (pegin_minimum.height < 0) {
+        throw std::runtime_error(strprintf("Invalid block height (%d) for -peginminheight. Must be positive.", pegin_minimum.height));
+    }
+    if (std::optional<CAmount> amount = ParseMoney(args.GetArg("-peginminamount", "0"))) {
+        pegin_minimum.amount = amount.value();
+    } else {
+        throw std::runtime_error("Invalid -peginminamount");
+    }
+
+    return pegin_minimum;
+};
+
 /**
  * Custom params for testing.
  */
@@ -932,6 +974,11 @@ class CCustomParams : public CRegTestParams {
         consensus.start_p2wsh_script = args.GetIntArg("-con_start_p2wsh_script", consensus.start_p2wsh_script);
         create_discount_ct = args.GetBoolArg("-creatediscountct", create_discount_ct);
         accept_discount_ct = args.GetBoolArg("-acceptdiscountct", accept_discount_ct) || create_discount_ct;
+        pegin_subsidy = ParsePeginSubsidy(args);
+        pegin_minimum = ParsePeginMinimum(args);
+        if (pegin_subsidy.threshold < pegin_minimum.amount) {
+            throw std::runtime_error(strprintf("Pegin subsidy threshold (%s) must be greater than or equal to pegin minimum amount (%s)", FormatMoney(pegin_subsidy.threshold), FormatMoney(pegin_minimum.amount)));
+        }
 
         // Calculate pegged Bitcoin asset
         std::vector<unsigned char> commit = CommitToArguments(consensus, strNetworkID);
@@ -1178,6 +1225,11 @@ class CLiquidV1Params : public CChainParams {
         multi_data_permitted = true;
         create_discount_ct = args.GetBoolArg("-creatediscountct", false);
         accept_discount_ct = args.GetBoolArg("-acceptdiscountct", true) || create_discount_ct;
+        pegin_subsidy = ParsePeginSubsidy(args);
+        pegin_minimum = ParsePeginMinimum(args);
+        if (pegin_subsidy.threshold < pegin_minimum.amount) {
+            throw std::runtime_error(strprintf("Pegin subsidy threshold (%s) must be greater than or equal to pegin minimum amount (%s)", FormatMoney(pegin_subsidy.threshold), FormatMoney(pegin_minimum.amount)));
+        }
 
         parentGenesisBlockHash = uint256S("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f");
         const bool parent_genesis_is_null = parentGenesisBlockHash == uint256();
@@ -1538,6 +1590,11 @@ class CLiquidV1TestParams : public CLiquidV1Params {
         multi_data_permitted = args.GetBoolArg("-multi_data_permitted", multi_data_permitted);
         create_discount_ct = args.GetBoolArg("-creatediscountct", create_discount_ct);
         accept_discount_ct = args.GetBoolArg("-acceptdiscountct", accept_discount_ct) || create_discount_ct;
+        pegin_subsidy = ParsePeginSubsidy(args);
+        pegin_minimum = ParsePeginMinimum(args);
+        if (pegin_subsidy.threshold < pegin_minimum.amount) {
+            throw std::runtime_error(strprintf("Pegin subsidy threshold (%s) must be greater than or equal to pegin minimum amount (%s)", FormatMoney(pegin_subsidy.threshold), FormatMoney(pegin_minimum.amount)));
+        }
 
         if (args.IsArgSet("-parentgenesisblockhash")) {
             parentGenesisBlockHash = uint256S(args.GetArg("-parentgenesisblockhash", ""));
diff --git a/src/chainparams.h b/src/chainparams.h
index 840a22ba5c..3e318577ec 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -28,6 +28,27 @@ struct CCheckpointData {
     }
 };
 
+// ELEMENTS
+struct PeginSubsidy {
+    int height{std::numeric_limits<int>::max()};
+    CAmount threshold{0};
+
+    PeginSubsidy() {};
+    bool IsDefined() {
+        return threshold > 0 || height < std::numeric_limits<int>::max();
+    };
+};
+
+struct PeginMinimum {
+    int height{std::numeric_limits<int>::max()};
+    CAmount amount{0};
+
+    PeginMinimum() {};
+    bool IsDefined() {
+        return amount > 0 || height < std::numeric_limits<int>::max();
+    };
+};
+
 struct AssumeutxoHash : public BaseHash<uint256> {
     explicit AssumeutxoHash(const uint256& hash) : BaseHash(hash) {}
 };
@@ -138,6 +159,8 @@ class CChainParams
     bool GetMultiDataPermitted() const { return multi_data_permitted; }
     bool GetAcceptDiscountCT() const { return accept_discount_ct; }
     bool GetCreateDiscountCT() const { return create_discount_ct; }
+    PeginSubsidy GetPeginSubsidy() const { return pegin_subsidy; }
+    PeginMinimum GetPeginMinimum() const { return pegin_minimum; }
 
 protected:
     CChainParams() {}
@@ -173,6 +196,8 @@ class CChainParams
     bool multi_data_permitted;
     bool accept_discount_ct;
     bool create_discount_ct;
+    PeginSubsidy pegin_subsidy;
+    PeginMinimum pegin_minimum;
 };
 
 /**
diff --git a/src/dynafed.cpp b/src/dynafed.cpp
index d719795149..cb288a83ed 100644
--- a/src/dynafed.cpp
+++ b/src/dynafed.cpp
@@ -123,3 +123,34 @@ DynaFedParamEntry ComputeNextBlockCurrentParameters(const CBlockIndex* pindexPre
     }
 }
 
+bool ParseFedPegQuorum(const CScript& fedpegscript, int& t, int& n) {
+    CScript::const_iterator it = fedpegscript.begin();
+    std::vector<unsigned char> vch;
+    opcodetype opcode;
+
+    // parse the required threshold number
+    if (!fedpegscript.GetOp(it, opcode, vch)) return false;
+    t = CScript::DecodeOP_N(opcode);
+    if (t < 1 || t > MAX_PUBKEYS_PER_MULTISIG) return false;
+
+    // support a fedpegscript like OP_TRUE if we're at the end of the script
+    if (it == fedpegscript.end()) return true;
+
+    // count the pubkeys
+    int pubkeys = 0;
+    while (fedpegscript.GetOp(it, opcode, vch)) {
+        if (opcode != 0x21) break;
+        if (vch.size() != 33) return false;
+        pubkeys++;
+    }
+
+    // parse the total number of pubkeys
+    n = CScript::DecodeOP_N(opcode);
+    if (n < 1 || n > MAX_PUBKEYS_PER_MULTISIG || n < t) return false;
+    if (pubkeys != n) return false;
+
+    // the next opcode must be OP_CHECKMULTISIG
+    if (!fedpegscript.GetOp(it, opcode, vch)) return false;
+
+    return opcode == OP_CHECKMULTISIG;
+}
diff --git a/src/dynafed.h b/src/dynafed.h
index ea651631fb..373fdb2e97 100644
--- a/src/dynafed.h
+++ b/src/dynafed.h
@@ -15,5 +15,10 @@ DynaFedParamEntry ComputeNextBlockFullCurrentParameters(const CBlockIndex* pinde
  * publish signblockscript-related fields */
 DynaFedParamEntry ComputeNextBlockCurrentParameters(const CBlockIndex* pindexPrev, const Consensus::Params& consensus);
 
+/* Get the threshold (t) and maybe the total pubkeys (n) of the first OP_CHECKMULTISIG in the fedpegscript.
+ * Assumes the fedpegscript starts with the threshold, otherwise returns false.
+ * Uses CScript::DecodeOP_N, so only supports up to a threshold of 16, otherwise asserts.
+ * Supports a fedpegscript like OP_TRUE by returning early. */
+bool ParseFedPegQuorum(const CScript& fedpegscript, int& t, int& n);
 
 #endif // BITCOIN_DYNAFED_H
diff --git a/src/init.cpp b/src/init.cpp
index 27addf275a..f2bbc8ed90 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -642,6 +642,10 @@ void SetupServerArgs(ArgsManager& argsman)
     argsman.AddArg("-ct_exponent", strprintf("The hiding exponent. (default: %s)", 0), ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
     argsman.AddArg("-acceptdiscountct", "Accept discounted fees for Confidential Transactions (default: 1 in liquidtestnet and liquidv1, 0 otherwise)", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
     argsman.AddArg("-creatediscountct", "Create Confidential Transactions with discounted fees (default: 0). Setting this to 1 will also set 'acceptdiscountct' to 1.", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
+    argsman.AddArg("-peginsubsidyheight", "The block height at which peg-in transactions must have a burn subsidy (default: not active). This is an OP_RETURN output with value of the parent transaction feerate times the cost of spending the WSH output (feerate * 396 sats for liquidv1). ", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
+    argsman.AddArg("-peginsubsidythreshold", "The output value below which peg-in transactions must have a burn subsidy (default: 0). Peg-ins above this value do not require the subsidy.", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
+    argsman.AddArg("-peginminheight", "The block height at which a minimum peg-in value is enforced (default: not active).", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
+    argsman.AddArg("-peginminamount", "The minimum value for a peg-in transaction after peginminheight (default: unset).", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
 
 #if defined(USE_SYSCALL_SANDBOX)
     argsman.AddArg("-sandbox=<mode>", "Use the experimental syscall sandbox in the specified mode (-sandbox=log-and-abort or -sandbox=abort). Allow only expected syscalls to be used by bitcoind. Note that this is an experimental new feature that may cause bitcoind to exit or crash unexpectedly: use with caution. In the \"log-and-abort\" mode the invocation of an unexpected syscall results in a debug handler being invoked which will log the incident and terminate the program (without executing the unexpected syscall). In the \"abort\" mode the invocation of an unexpected syscall results in the entire process being killed immediately by the kernel without executing the unexpected syscall.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
@@ -1975,6 +1979,23 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
                 gArgs.SoftSetArg("-validatepegin", "0");
             }
         }
+        // if we are validating pegin subsidy or minimum then we require bitcoind >= v25
+        if (Params().GetPeginSubsidy().IsDefined() || Params().GetPeginMinimum().IsDefined()) {
+            UniValue params(UniValue::VARR);
+            UniValue reply = CallMainChainRPC("getnetworkinfo", params);
+            if (reply["error"].isStr()) {
+                InitError(Untranslated(reply["error"].get_str()));
+                return false;
+            } else {
+                const int version = reply["result"]["version"].get_int();
+                const std::string& subversion = reply["result"]["subversion"].get_str();
+                if (version < 250000 && subversion.find("Satoshi") != std::string::npos) {
+                    const std::string err = strprintf("ERROR: parent bitcoind must be version 25 or newer for pegin subsidy/minimum validation. Found version: %s", version);
+                    InitError(Untranslated(err));
+                    return false;
+                }
+            }
+        }
     }
 
     // Call ActivateBestChain every 30 seconds. This is almost always a
diff --git a/src/pegins.cpp b/src/pegins.cpp
index 72551d2c3b..8e44936398 100644
--- a/src/pegins.cpp
+++ b/src/pegins.cpp
@@ -577,7 +577,7 @@ bool DecomposePeginWitness(const CScriptWitness& witness, CAmount& value, CAsset
         tx = elem_tx;
     }
 
-    CDataStream ss_proof(stack[5], SER_NETWORK, PROTOCOL_VERSION);
+    CDataStream ss_proof(stack[5], SER_NETWORK, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS);
     if (Params().GetConsensus().ParentChainHasPow()) {
         Sidechain::Bitcoin::CMerkleBlock tx_proof;
         ss_proof >> tx_proof;
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index b20765a9e2..602cd5d952 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -40,6 +40,7 @@
 #include <txdb.h>
 #include <txmempool.h>
 #include <undo.h>
+#include <util/moneystr.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/translation.h>
@@ -3134,6 +3135,25 @@ static RPCHelpMan getsidechaininfo()
         obj.pushKV("parent_chain_signblockscript_hex", HexStr(consensus.parent_chain_signblockscript));
         obj.pushKV("parent_pegged_asset", consensus.parent_pegged_asset.GetHex());
     }
+
+    PeginMinimum pegin_minimum = Params().GetPeginMinimum();
+    if (pegin_minimum.amount > 0) {
+        obj.pushKV("pegin_min_amount", FormatMoney(pegin_minimum.amount));
+    }
+    if (pegin_minimum.height < std::numeric_limits<int>::max()) {
+        obj.pushKV("pegin_min_height", pegin_minimum.height);
+        obj.pushKV("pegin_min_active", chainman.ActiveTip()->nHeight >= pegin_minimum.height);
+    }
+
+    PeginSubsidy pegin_subsidy = Params().GetPeginSubsidy();
+    if (pegin_subsidy.threshold > 0) {
+        obj.pushKV("pegin_subsidy_threshold", FormatMoney(pegin_subsidy.threshold));
+    }
+    if (pegin_subsidy.height < std::numeric_limits<int>::max()) {
+        obj.pushKV("pegin_subsidy_height", pegin_subsidy.height);
+        obj.pushKV("pegin_subsidy_active", chainman.ActiveTip()->nHeight >= pegin_subsidy.height);
+    }
+
     return obj;
 },
     };
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 5d8da16722..3b65133921 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -239,6 +239,8 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "calculateasset", 3, "blind_reissuance" },
     { "updatepsbtpegin", 1, "input" },
     { "updatepsbtpegin", 2, "value" },
+    { "claimpegin", 3, "fee_rate" },
+    { "createrawpegin", 3, "fee_rate" },
 
 };
 // clang-format on
diff --git a/src/test/dynafed_tests.cpp b/src/test/dynafed_tests.cpp
index 3a186db51c..f9a8099ae1 100644
--- a/src/test/dynafed_tests.cpp
+++ b/src/test/dynafed_tests.cpp
@@ -2,12 +2,13 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <test/util/setup_common.h>
-#include <string>
 #include <boost/test/unit_test.hpp>
+#include <dynafed.h>
 #include <primitives/block.h>
 #include <script/script.h>
 #include <serialize.h>
+#include <string>
+#include <test/util/setup_common.h>
 
 
 BOOST_FIXTURE_TEST_SUITE(dynafed_tests, BasicTestingSetup)
@@ -41,6 +42,48 @@ BOOST_AUTO_TEST_CASE(dynafed_params_root)
     );
 }
 
-BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_CASE(parse_fedpegscript_multisig)
+{
+    int t = 0;
+    int n = 0;
+
+    auto simplebytes = ParseHex("512103dff4923d778550cc13ce0d887d737553b4b58f4e8e886507fc39f5e447b2186451ae");
+
+    CScript simple{simplebytes.begin(), simplebytes.end()};
+
+    BOOST_CHECK(ParseFedPegQuorum(simple, t, n));
+    BOOST_CHECK_EQUAL(t, 1);
+    BOOST_CHECK_EQUAL(n, 1);
+
+    auto liquidv1bytes = ParseHex("5b21020e0338c96a8870479f2396c373cc7696ba124e8635d41b0ea581112b678172612102675333a4e4b8fb51d9d4e22fa5a8eaced3fdac8a8cbf9be8c030f75712e6af992102896807d54bc55c24981f24a453c60ad3e8993d693732288068a23df3d9f50d4821029e51a5ef5db3137051de8323b001749932f2ff0d34c82e96a2c2461de96ae56c2102a4e1a9638d46923272c266631d94d36bdb03a64ee0e14c7518e49d2f29bc401021031c41fdbcebe17bec8d49816e00ca1b5ac34766b91c9f2ac37d39c63e5e008afb2103079e252e85abffd3c401a69b087e590a9b86f33f574f08129ccbd3521ecf516b2103111cf405b627e22135b3b3733a4a34aa5723fb0f58379a16d32861bf576b0ec2210318f331b3e5d38156da6633b31929c5b220349859cc9ca3d33fb4e68aa08401742103230dae6b4ac93480aeab26d000841298e3b8f6157028e47b0897c1e025165de121035abff4281ff00660f99ab27bb53e6b33689c2cd8dcd364bc3c90ca5aea0d71a62103bd45cddfacf2083b14310ae4a84e25de61e451637346325222747b157446614c2103cc297026b06c71cbfa52089149157b5ff23de027ac5ab781800a578192d175462103d3bde5d63bdb3a6379b461be64dad45eabff42f758543a9645afd42f6d4248282103ed1e8d5109c9ed66f7941bc53cc71137baa76d50d274bda8d5e8ffbd6e61fe9a5fae736402c00fb269522103aab896d53a8e7d6433137bbba940f9c521e085dd07e60994579b64a6d992cf79210291b7d0b1b692f8f524516ed950872e5da10fb1b808b5a526dedc6fed1cf29807210386aa9372fbab374593466bc5451dc59954e90787f08060964d95c87ef34ca5bb53ae68");
 
+    CScript liquidv1{liquidv1bytes.begin(), liquidv1bytes.end()};
 
+    t = 0;
+    n = 0;
+    BOOST_CHECK(ParseFedPegQuorum(liquidv1, t, n));
+    BOOST_CHECK_EQUAL(t, 11);
+    BOOST_CHECK_EQUAL(n, 15);
+
+    auto optruebytes = ParseHex("51");
+
+    CScript optrue{optruebytes.begin(), optruebytes.end()};
+
+    t = 0;
+    n = 0;
+    BOOST_CHECK(ParseFedPegQuorum(optrue, t, n));
+    BOOST_CHECK_EQUAL(t, 1);
+    BOOST_CHECK_EQUAL(n, 0);
+
+    auto op3bytes = ParseHex("53");
+
+    CScript op3{op3bytes.begin(), op3bytes.end()};
+
+    t = 0;
+    n = 0;
+    BOOST_CHECK(ParseFedPegQuorum(op3, t, n));
+    BOOST_CHECK_EQUAL(t, 3);
+    BOOST_CHECK_EQUAL(n, 0);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/validation.cpp b/src/validation.cpp
index 6ac82e3e98..1e0fa0d32a 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -663,6 +663,135 @@ class MemPoolAccept
         return true;
     }
 
+    // ELEMENTS: check if peg-in transaction pays the burn subsidy, and if minimum peg-in amount is met
+    bool CheckPeginSubsidyAndMinimum(TxValidationState& state, const CTransaction& tx, const std::vector<unsigned int>& pegin_indices)
+    {
+        // pegin_indices was calculated directly from the tx in prechecks, assert this invariant
+        assert(tx.witness.vtxinwit.size() >= pegin_indices.size());
+
+        if (pegin_indices.size() > 0) {
+            // calculate the burned subsidy value from the tx
+            CAmount subsidy = 0;
+            for (const CTxOut& txout : tx.vout) {
+                if (txout.scriptPubKey.IsUnspendable() && txout.nAsset.GetAsset() == Params().GetConsensus().pegged_asset && !txout.IsFee()) {
+                    subsidy += txout.nValue.GetAmount();
+                }
+            }
+            // calculate the peg-in value, fee, and vsize from the parent chain if we are validating peg-ins
+            // if validatepegin=0 then the minimum 1 sat/vb subsidy applies
+            CAmount value = 0;
+            CAmount parent_fee = 0;
+            uint32_t parent_vsize = 0;
+            for (size_t i = 0; i < pegin_indices.size(); ++i) {
+                // get the parent txid and blockhash from the peg-in witness data
+                CAmount pvalue;
+                CAsset passet;
+                uint256 pgenesis;
+                CScript pscript;
+                std::variant<std::monostate, Sidechain::Bitcoin::CTransactionRef, CTransactionRef> ptx;
+                std::variant<std::monostate, Sidechain::Bitcoin::CMerkleBlock, CMerkleBlock> pmerkle;
+
+                if (!DecomposePeginWitness(tx.witness.vtxinwit[pegin_indices[i]].m_pegin_witness, pvalue, passet, pgenesis, pscript, ptx, pmerkle)) {
+                    return state.Invalid(TxValidationResult::TX_NOT_STANDARD, "pegin-invalid-parent-tx", "failed to decompose the parent peg-in witness");
+                }
+                if (passet != Params().GetConsensus().pegged_asset) {
+                    return state.Invalid(TxValidationResult::TX_NOT_STANDARD, "pegin-invalid-asset", "pegin asset is not the pegged asset");
+                }
+
+                value += pvalue;
+
+                uint256 txid;
+                switch (ptx.index()) {
+                case 0:
+                    // this should never happen, but fail gracefully by rejecting
+                    return false;
+                case 1:
+                    txid = std::get<Sidechain::Bitcoin::CTransactionRef>(ptx)->GetHash();
+                    break;
+                case 2:
+                    txid = std::get<CTransactionRef>(ptx)->GetHash();
+                    break;
+                }
+                uint256 blockhash;
+                switch (pmerkle.index()) {
+                case 0:
+                    return false;
+                case 1:
+                    blockhash = std::get<Sidechain::Bitcoin::CMerkleBlock>(pmerkle).header.GetHash();
+                    break;
+                case 2:
+                    blockhash = std::get<CMerkleBlock>(pmerkle).header.GetHash();
+                    break;
+                }
+
+                // get the parent transaction fee, to calculate the fee rate
+                if (gArgs.GetBoolArg("-validatepegin", Params().GetConsensus().has_parent_chain)) {
+                    UniValue params(UniValue::VARR);
+                    params.push_back(txid.GetHex());
+                    params.push_back(2);
+                    params.push_back(blockhash.GetHex());
+                    UniValue result = CallMainChainRPC("getrawtransaction", params);
+                    if (result["error"].isStr()) {
+                        return state.Invalid(TxValidationResult::TX_NOT_STANDARD, "pegin-subsidy-mainchain-error", result["error"]["message"].get_str());
+                    } else {
+                        parent_vsize += result["result"]["vsize"].get_int64();
+                        if (result["result"]["fee"].isNum()) {
+                            // bitcoin core v25+ returns the fee amount
+                            parent_fee += static_cast<CAmount>(std::round(result["result"]["fee"].get_real() * COIN));
+                        } else if (result["result"]["fee"].isObject()) {
+                            // elements returns a fee object
+                            std::string asset = Params().GetConsensus().parent_pegged_asset.GetHex();
+                            if (result["result"]["fee"][asset].isNum()) {
+                                parent_fee += static_cast<CAmount>(std::round(result["result"]["fee"][asset].get_real() * COIN));
+                            }
+                        }
+                    }
+                }
+            }
+
+            // check if the peg-in value meets the minimum amount
+            PeginMinimum pegin_minimum = Params().GetPeginMinimum();
+            if (m_active_chainstate.m_chain.Height() >= pegin_minimum.height && value < pegin_minimum.amount) {
+                // peg-in value is lower than the minimum
+                return state.Invalid(TxValidationResult::TX_NOT_STANDARD, "pegin-value-too-low", strprintf("peg-in value: %d, minimum peg-in value: %d", FormatMoney(value), FormatMoney(pegin_minimum.amount)));
+            }
+
+            if (m_active_chainstate.m_chain.Height() >= Params().GetPeginSubsidy().height) {
+                // subsidy is required at this height
+                // when parent feerate is less than 1 sat/vb, use 1 sat/vb for the calculation
+                CFeeRate parent_feerate = std::max(CFeeRate{parent_fee, parent_vsize}, CFeeRate{1000});
+
+                // for peg-ins below the subsidy threshold, check for enough subsidy
+                CAmount threshold = Params().GetPeginSubsidy().threshold;
+                // calculate the subsidy as the amount required to spend the P2WSH output
+                const auto& fedpegscripts = GetValidFedpegScripts(m_active_chainstate.m_chain.Tip(), Params().GetConsensus(), true /* nextblock_validation */);
+                int t = 0;
+                int n = 0;
+                if (fedpegscripts.size() == 0) return false;
+                if (!ParseFedPegQuorum(fedpegscripts[0].second, t, n)) return false;
+
+                // each P2WSH input is 41 bytes: txid (32) + vout (4) + scriptsig len (1) + sequence (4)
+                // the witness to spend is `t` signatures + the script size
+                unsigned int weight = WITNESS_SCALE_FACTOR * (32 + 4 + 1 + 4) + (t * 72 + fedpegscripts[0].second.size());
+                unsigned int vbytes = (weight + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
+
+                // multiply by the number of peg-ins
+                CAmount expected_subsidy = parent_feerate.GetFee(pegin_indices.size() * vbytes);
+                if (value < threshold && subsidy < expected_subsidy) {
+                    return state.Invalid(TxValidationResult::TX_NOT_STANDARD, "pegin-subsidy-too-low",
+                                         strprintf("peg-in value: %d, subsidy threshold: %d, subsidy value: %d, expected subsidy: %d, parent feerate: %s",
+                                                   FormatMoney(value), FormatMoney(threshold), FormatMoney(subsidy), FormatMoney(expected_subsidy), parent_feerate.ToString()));
+                }
+            }
+        }
+
+        // either validatepegin=0 and we can't calculate peg-in value and parent feerate
+        // or we're below the subsidy height
+        // or the peg-in value is above the subsidy threshold
+        // or the peg-in paid enough subsidy
+        return true;
+    }
+
 private:
     CTxMemPool& m_pool;
     CCoinsViewCache m_view;
@@ -795,6 +924,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     std::vector<std::pair<CScript, CScript>> fedpegscripts = GetValidFedpegScripts(m_active_chainstate.m_chain.Tip(), chainparams.GetConsensus(), true /* nextblock_validation */);
 
     const CCoinsViewCache& coins_cache = m_active_chainstate.CoinsTip();
+    std::vector<unsigned int> pegin_indices;
     // do all inputs exist?
     for (unsigned int i = 0; i < tx.vin.size(); i++) {
         const CTxIn& txin = tx.vin[i];
@@ -816,6 +946,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
             if (m_view.IsPeginSpent(pegin)) {
                 return state.Invalid(TxValidationResult::TX_CONSENSUS, "pegin-already-claimed");
             }
+            pegin_indices.push_back(i);
             continue;
         }
 
@@ -922,6 +1053,8 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     // ELEMENTS: accept discounted fees for Confidential Transactions only, if enabled.
     int64_t package_size = Params().GetAcceptDiscountCT() ? GetDiscountVirtualTransactionSize(tx) : ws.m_vsize;
     if (!bypass_limits && !CheckFeeRate(package_size, ws.m_modified_fees, state)) return false;
+    // ELEMENTS: check if peg-in subsidy is required and min peg-in amount is met
+    if (!CheckPeginSubsidyAndMinimum(state, tx, pegin_indices)) return false;
 
     ws.m_iters_conflicting = m_pool.GetIterSet(ws.m_conflicts);
     // Calculate in-mempool ancestors, up to a limit.
diff --git a/src/wallet/rpc/elements.cpp b/src/wallet/rpc/elements.cpp
index 798c218249..93aab0b02d 100644
--- a/src/wallet/rpc/elements.cpp
+++ b/src/wallet/rpc/elements.cpp
@@ -6,6 +6,7 @@
 #include <block_proof.h>
 #include <core_io.h>
 #include <deploymentstatus.h>
+#include <dynafed.h>
 #include <issuance.h>
 #include <key_io.h>
 #include <mainchainrpc.h>
@@ -15,10 +16,11 @@
 #include <script/generic.hpp>
 #include <script/pegins.h>
 #include <secp256k1.h>
+#include <util/moneystr.h>
 #include <wallet/coincontrol.h>
 #include <wallet/fees.h>
-#include <wallet/rpc/util.h>
 #include <wallet/receive.h>
+#include <wallet/rpc/util.h>
 #include <wallet/spend.h>
 #include <wallet/wallet.h>
 
@@ -220,6 +222,25 @@ RPCHelpMan getpeginaddress()
 
     ret.pushKV("mainchain_address", EncodeParentDestination(mainchain_dest));
     ret.pushKV("claim_script", HexStr(dest_script));
+
+    PeginMinimum pegin_minimum = Params().GetPeginMinimum();
+    if (pegin_minimum.amount > 0) {
+        ret.pushKV("pegin_min_amount", FormatMoney(pegin_minimum.amount));
+    }
+    if (pegin_minimum.height < std::numeric_limits<int>::max()) {
+        ret.pushKV("pegin_min_height", pegin_minimum.height);
+        ret.pushKV("pegin_min_active", wallet->chain().getTip()->nHeight >= pegin_minimum.height);
+    }
+
+    PeginSubsidy pegin_subsidy = Params().GetPeginSubsidy();
+    if (pegin_subsidy.threshold > 0) {
+        ret.pushKV("pegin_subsidy_threshold", FormatMoney(pegin_subsidy.threshold));
+    }
+    if (pegin_subsidy.height < std::numeric_limits<int>::max()) {
+        ret.pushKV("pegin_subsidy_height", pegin_subsidy.height);
+        ret.pushKV("pegin_subsidy_active", wallet->chain().getTip()->nHeight >= pegin_subsidy.height);
+    }
+
     return ret;
 },
     };
@@ -787,7 +808,7 @@ RPCHelpMan sendtomainchain()
 extern UniValue signrawtransaction(const JSONRPCRequest& request);
 extern UniValue sendrawtransaction(const JSONRPCRequest& request);
 
-template<typename T_tx_ref, typename T_merkle_block>
+template <typename T_tx_ref, typename T_merkle_block>
 static UniValue createrawpegin(const JSONRPCRequest& request, T_tx_ref& txBTCRef, T_merkle_block& merkleBlock)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
@@ -824,6 +845,59 @@ static UniValue createrawpegin(const JSONRPCRequest& request, T_tx_ref& txBTCRef
     // Construct pegin input
     CreatePegInInput(mtx, 0, txBTCRef, merkleBlock, claim_scripts, txData, txOutProofData, wallet->chain().getTip());
 
+    // Get value for peg-in output
+    CAmount value = 0;
+    if (!GetAmountFromParentChainPegin(value, *txBTCRef, mtx.vin[0].prevout.n)) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Amounts to pegin must be explicit and asset must be %s", Params().GetConsensus().parent_pegged_asset.GetHex()));
+    }
+
+    const PeginMinimum pegin_minimum = Params().GetPeginMinimum();
+    if (pwallet->chain().getTip()->nHeight >= pegin_minimum.height && value < pegin_minimum.amount) {
+        throw JSONRPCError(RPC_WALLET_ERROR, strprintf("Pegin amount (%d) is lower than the minimum pegin amount for this chain (%d).", FormatMoney(value), FormatMoney(pegin_minimum.amount)));
+    }
+
+    const PeginSubsidy pegin_subsidy = Params().GetPeginSubsidy();
+    bool subsidy_required = pwallet->chain().getTip()->nHeight >= pegin_subsidy.height && value < pegin_subsidy.threshold;
+    if (subsidy_required && !gArgs.GetBoolArg("-validatepegin", Params().GetConsensus().has_parent_chain) && request.params[3].isNull()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Bitcoin transaction fee rate must be supplied, because validatepegin is off and this peg-in requires a burn subsidy.");
+    }
+
+    CAmount fee = 0;
+    uint32_t parent_vsize = 0;
+    CFeeRate feerate = CFeeRate{0};
+    if (gArgs.GetBoolArg("-validatepegin", false) && subsidy_required) {
+        std::string txid = txBTCRef->GetHash().ToString();
+        std::string blockhash = merkleBlock.header.GetHash().ToString();
+        UniValue params(UniValue::VARR);
+        params.push_back(txid);
+        params.push_back(2);
+        params.push_back(blockhash);
+        UniValue result = CallMainChainRPC("getrawtransaction", params);
+        if (result["error"].isStr()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, result["error"]["message"].get_str());
+        } else {
+            parent_vsize = result["result"]["vsize"].get_int64();
+            if (result["result"]["fee"].isNum()) {
+                fee = static_cast<CAmount>(std::round(result["result"]["fee"].get_real() * COIN));
+            } else if (result["result"]["fee"].isObject()) {
+                std::string asset = Params().GetConsensus().parent_pegged_asset.GetHex();
+                if (result["result"]["fee"][asset].isNum()) {
+                    fee = static_cast<CAmount>(std::round(result["result"]["fee"][asset].get_real() * COIN));
+                } else {
+                    throw JSONRPCError(RPC_MISC_ERROR, "No fee result for the parent pegged asset.");
+                }
+            } else {
+                throw JSONRPCError(RPC_MISC_ERROR, "Fee result is not a number or object.");
+            }
+            // when parent feerate is less than 1 sat/vb, use 1 sat/vb for the calculation
+            feerate = std::max(CFeeRate{fee, parent_vsize}, CFeeRate{1000});
+        }
+    } else if (!request.params[3].isNull()) {
+        // manual feerate, specified in sats/vb but CFeeRate takes sats/Kvb
+        CAmount satsperk = static_cast<CAmount>(std::round(request.params[3].get_real() * 1000));
+        feerate = std::max(CFeeRate{satsperk}, CFeeRate{1000});
+    }
+
     // Manually construct peg-in transaction, sign it, and send it off.
     // Decrement the output value as much as needed given the total vsize to
     // pay the fees.
@@ -838,19 +912,17 @@ static UniValue createrawpegin(const JSONRPCRequest& request, T_tx_ref& txBTCRef
         throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, error.original);
     }
 
-    // Get value for output
-    CAmount value = 0;
-    if (!GetAmountFromParentChainPegin(value, *txBTCRef, mtx.vin[0].prevout.n)) {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Amounts to pegin must be explicit and asset must be %s", Params().GetConsensus().parent_pegged_asset.GetHex()));
-    }
-
-    // one wallet output and one fee output
+    // add a wallet output for the peg-in value
     mtx.vout.push_back(CTxOut(Params().GetConsensus().pegged_asset, value, GetScriptForDestination(wpkhash)));
+    if (subsidy_required) {
+        // add an op_return for the peg-in fee subsidy
+        mtx.vout.push_back(CTxOut(Params().GetConsensus().pegged_asset, 0, CScript() << OP_RETURN));
+    }
+    // add a fee output
     mtx.vout.push_back(CTxOut(Params().GetConsensus().pegged_asset, 0, CScript()));
 
-    // Estimate fee for transaction, decrement fee output(including witness data)
-    unsigned int nBytes = GetVirtualTransactionSize(CTransaction(mtx)) +
-        (1+1+72+1+33)/WITNESS_SCALE_FACTOR;
+    // Estimate fee for transaction, decrement fee output (including witness data)
+    unsigned int nBytes = GetVirtualTransactionSize(CTransaction(mtx)) + (1 + 1 + 72 + 1 + 33) / WITNESS_SCALE_FACTOR;
     CCoinControl coin_control;
     FeeCalculation feeCalc;
     CAmount nFeeNeeded = GetMinimumFee(*pwallet, nBytes, coin_control, &feeCalc);
@@ -859,8 +931,35 @@ static UniValue createrawpegin(const JSONRPCRequest& request, T_tx_ref& txBTCRef
         throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Fee estimation failed. Fallbackfee is disabled. Wait a few blocks or enable -fallbackfee.");
     }
 
-    mtx.vout[0].nValue = mtx.vout[0].nValue.GetAmount() - nFeeNeeded;
-    mtx.vout[1].nValue = mtx.vout[1].nValue.GetAmount() + nFeeNeeded;
+    if (subsidy_required) {
+        CHECK_NONFATAL(mtx.vout.size() == 3);
+
+        // calculate the subsidy as the amount required to spend the P2WSH output
+        const auto& fedpegscripts = GetValidFedpegScripts(pwallet->chain().getTip(), Params().GetConsensus(), true /* nextblock_validation */);
+        int t = 0;
+        int n = 0;
+        CHECK_NONFATAL(fedpegscripts.size() > 0);
+        CHECK_NONFATAL(ParseFedPegQuorum(fedpegscripts[0].second, t, n));
+
+        // P2WSH input is 41 bytes: txid (32) + vout (4) + scriptsig len (1) + sequence (4)
+        // the witness to spend is `t` signatures + the script size
+        unsigned int weight = WITNESS_SCALE_FACTOR * (32 + 4 + 1 + 4) + (t * 72 + fedpegscripts[0].second.size());
+        unsigned int vbytes = (weight + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
+
+        CAmount subsidy = feerate.GetFee(vbytes);
+
+        CAmount value = mtx.vout[0].nValue.GetAmount() - nFeeNeeded - subsidy;
+        mtx.vout[0].nValue = value;
+        mtx.vout[1].nValue = subsidy;
+        mtx.vout[2].nValue = nFeeNeeded;
+        if (IsDust(mtx.vout[0], pwallet->chain().relayDustFee())) {
+            throw JSONRPCError(RPC_WALLET_ERROR, "Peg-in transaction would create dust output.");
+        }
+    } else {
+        CHECK_NONFATAL(mtx.vout.size() == 2);
+        mtx.vout[0].nValue = mtx.vout[0].nValue.GetAmount() - nFeeNeeded;
+        mtx.vout[1].nValue = nFeeNeeded;
+    }
 
     UniValue ret(UniValue::VOBJ);
 
@@ -893,6 +992,7 @@ RPCHelpMan createrawpegin()
                     {"bitcoin_tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The raw bitcoin transaction (in hex) depositing bitcoin to the mainchain_address generated by getpeginaddress"},
                     {"txoutproof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "A rawtxoutproof (in hex) generated by the mainchain daemon's `gettxoutproof` containing a proof of only bitcoin_tx"},
                     {"claim_script", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED_NAMED_ARG, "The witness program generated by getpeginaddress. Only needed if not in wallet."},
+                    {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::Optional::OMITTED_NAMED_ARG, "The fee rate of the Bitcoin transaction in sats/vb, only necessary when validatepegin=0."},
                 },
                 RPCResult{
                     RPCResult::Type::OBJ, "", "",
@@ -942,6 +1042,7 @@ RPCHelpMan claimpegin()
                     {"bitcoin_tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The raw bitcoin transaction (in hex) depositing bitcoin to the mainchain_address generated by getpeginaddress"},
                     {"txoutproof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "A rawtxoutproof (in hex) generated by the mainchain daemon's `gettxoutproof` containing a proof of only bitcoin_tx"},
                     {"claim_script", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED_NAMED_ARG, "The witness program generated by getpeginaddress. Only needed if not in wallet."},
+                    {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::Optional::OMITTED_NAMED_ARG, "The fee rate of the Bitcoin transaction in sats/vb, only necessary when validatepegin=0."},
                 },
                 RPCResult{
                     RPCResult::Type::STR_HEX, "txid", "txid of the resulting sidechain transaction",
diff --git a/test/functional/feature_pegin_subsidy.py b/test/functional/feature_pegin_subsidy.py
new file mode 100755
index 0000000000..695cae0935
--- /dev/null
+++ b/test/functional/feature_pegin_subsidy.py
@@ -0,0 +1,921 @@
+#!/usr/bin/env python3
+
+# can be run with parent bitcoind node
+# tested with bitcoind v28.2 and v29.0
+# test/functional/feature_pegin_subsidy.py --parent_bitcoin --parent_binpath="/path/to/bitcoind" --nosandbox
+
+from decimal import Decimal
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_raises_rpc_error,
+    find_vout_for_address,
+    get_auth_cookie,
+    get_datadir_path,
+    rpc_port,
+    p2p_port,
+    assert_equal,
+)
+from test_framework import util
+
+PEGIN_MINIMUM_HEIGHT = 102
+PEGIN_SUBSIDY_HEIGHT = 150
+
+
+def get_new_unconfidential_address(node, addr_type="bech32"):
+    addr = node.getnewaddress("", addr_type)
+    val_addr = node.getaddressinfo(addr)
+    if "unconfidential" in val_addr:
+        return val_addr["unconfidential"]
+    return val_addr["address"]
+
+
+class PeginSubsidyTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.setup_clean_chain = True
+        self.num_nodes = 3
+        self.disable_syscall_sandbox = True
+
+    def add_options(self, parser):
+        parser.add_argument(
+            "--parent_binpath",
+            dest="parent_binpath",
+            default="",
+            help="Use a different binary for launching nodes",
+        )
+        parser.add_argument(
+            "--parent_bitcoin",
+            dest="parent_bitcoin",
+            default=False,
+            action="store_true",
+            help="Parent nodes are Bitcoin",
+        )
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def setup_network(self, split=False):
+        if self.options.parent_bitcoin and self.options.parent_binpath == "":
+            raise Exception("Can't run with --parent_bitcoin without specifying --parent_binpath")
+
+        self.nodes = []
+        # Setup parent nodes
+        parent_chain = "elementsregtest" if not self.options.parent_bitcoin else "regtest"
+        parent_binary = [self.options.parent_binpath] if self.options.parent_binpath != "" else None
+
+        extra_args = [
+            "-port=" + str(p2p_port(0)),
+            "-rpcport=" + str(rpc_port(0)),
+            # to test minimum parent tx fee
+            "-minrelaytxfee=0.00000100",
+            "-blockmintxfee=0.00000100",
+            "-mintxfee=0.00000100",
+        ]
+        if self.options.parent_bitcoin:
+            # bitcoind can't read elements.conf config files
+            extra_args.extend(
+                [
+                    "-regtest=1",
+                    "-printtoconsole=0",
+                    "-server=1",
+                    "-discover=0",
+                    "-keypool=1",
+                    "-listenonion=0",
+                    "-addresstype=legacy",  # To make sure bitcoind gives back p2pkh no matter version
+                    "-fallbackfee=0.0002",
+                    "-deprecatedrpc=create_bdb",
+                ]
+            )
+            self.expected_stderr = (
+                f"Error: Unable to bind to 127.0.0.1:{p2p_port(1)} on this computer. Elements Core is probably already running."
+            )
+        else:
+            extra_args.extend(
+                [
+                    "-validatepegin=0",
+                    "-initialfreecoins=0",
+                    "-anyonecanspendaremine=1",
+                    "-signblockscript=51",  # OP_TRUE
+                    "-dustrelayfee=0.00003000",  # use the Bitcoin default dust relay fee rate for the parent nodes
+                ]
+            )
+            self.expected_stderr = ""
+
+        self.add_nodes(1, [extra_args], chain=[parent_chain], binary=parent_binary)
+        self.start_node(0)
+        self.log.info(f"Node 0 started (mainchain: {'bitcoind' if self.options.parent_bitcoin else 'elementsd'})")
+
+        # set hard-coded mining keys for non-Elements chains
+        if self.options.parent_bitcoin:
+            self.nodes[0].set_deterministic_priv_key(
+                "2Mysp7FKKe52eoC2JmU46irt1dt58TpCvhQ",
+                "cTNbtVJmhx75RXomhYWSZAafuNNNKPd1cr2ZiUcAeukLNGrHWjvJ",
+            )
+
+        self.parentgenesisblockhash = self.nodes[0].getblockhash(0)
+        if not self.options.parent_bitcoin:
+            parent_pegged_asset = self.nodes[0].getsidechaininfo()["pegged_asset"]
+
+        # Setup sidechain nodes
+        # use the current liquidv1 fedpegscript for testing purposes
+        self.fedpegscript = "5b21020e0338c96a8870479f2396c373cc7696ba124e8635d41b0ea581112b678172612102675333a4e4b8fb51d9d4e22fa5a8eaced3fdac8a8cbf9be8c030f75712e6af992102896807d54bc55c24981f24a453c60ad3e8993d693732288068a23df3d9f50d4821029e51a5ef5db3137051de8323b001749932f2ff0d34c82e96a2c2461de96ae56c2102a4e1a9638d46923272c266631d94d36bdb03a64ee0e14c7518e49d2f29bc401021031c41fdbcebe17bec8d49816e00ca1b5ac34766b91c9f2ac37d39c63e5e008afb2103079e252e85abffd3c401a69b087e590a9b86f33f574f08129ccbd3521ecf516b2103111cf405b627e22135b3b3733a4a34aa5723fb0f58379a16d32861bf576b0ec2210318f331b3e5d38156da6633b31929c5b220349859cc9ca3d33fb4e68aa08401742103230dae6b4ac93480aeab26d000841298e3b8f6157028e47b0897c1e025165de121035abff4281ff00660f99ab27bb53e6b33689c2cd8dcd364bc3c90ca5aea0d71a62103bd45cddfacf2083b14310ae4a84e25de61e451637346325222747b157446614c2103cc297026b06c71cbfa52089149157b5ff23de027ac5ab781800a578192d175462103d3bde5d63bdb3a6379b461be64dad45eabff42f758543a9645afd42f6d4248282103ed1e8d5109c9ed66f7941bc53cc71137baa76d50d274bda8d5e8ffbd6e61fe9a5fae736402c00fb269522103aab896d53a8e7d6433137bbba940f9c521e085dd07e60994579b64a6d992cf79210291b7d0b1b692f8f524516ed950872e5da10fb1b808b5a526dedc6fed1cf29807210386aa9372fbab374593466bc5451dc59954e90787f08060964d95c87ef34ca5bb53ae68"
+        for n in range(2):
+            validatepegin = "1" if n == 0 else "0"
+            extra_args = [
+                "-printtoconsole=0",
+                "-port=" + str(p2p_port(1 + n)),
+                "-rpcport=" + str(rpc_port(1 + n)),
+                "-validatepegin=%s" % validatepegin,
+                "-fallbackfee=0.00001000",
+                "-fedpegscript=%s" % self.fedpegscript,
+                "-minrelaytxfee=0",
+                "-blockmintxfee=0",
+                "-initialfreecoins=0",
+                "-peginconfirmationdepth=10",
+                "-mainchainrpchost=127.0.0.1",
+                "-mainchainrpcport=%s" % rpc_port(0),
+                "-parentgenesisblockhash=%s" % self.parentgenesisblockhash,
+                "-parentpubkeyprefix=111",
+                "-parentscriptprefix=196",
+                "-parent_bech32_hrp=bcrt",
+                # Turn of consistency checks that can cause assert when parent node stops
+                # and a peg-in transaction fails this belt-and-suspenders check.
+                # NOTE: This can cause spurious problems in regtest, and should be dealt with in a better way.
+                "-checkmempool=0",
+                "-peginsubsidyheight=%s" % PEGIN_SUBSIDY_HEIGHT,
+                "-peginsubsidythreshold=2.0",
+                "-peginminheight=%s" % PEGIN_MINIMUM_HEIGHT,
+                "-peginminamount=1.0",
+            ]
+            if not self.options.parent_bitcoin:
+                extra_args.extend(
+                    [
+                        "-parentpubkeyprefix=235",
+                        "-parentscriptprefix=75",
+                        "-parent_bech32_hrp=ert",
+                        "-con_parent_chain_signblockscript=51",
+                        "-con_parent_pegged_asset=%s" % parent_pegged_asset,
+                    ]
+                )
+
+            # Use rpcuser auth only for first parent.
+            if n == 0:
+                # Extract username and password from cookie file and use directly.
+                datadir = get_datadir_path(self.options.tmpdir, n)
+                rpc_u, rpc_p = get_auth_cookie(datadir, parent_chain)
+                extra_args.extend(
+                    [
+                        "-mainchainrpcuser=%s" % rpc_u,
+                        "-mainchainrpcpassword=%s" % rpc_p,
+                    ]
+                )
+            else:
+                # Need to specify where to find parent cookie file
+                datadir = get_datadir_path(self.options.tmpdir, n)
+                extra_args.append("-mainchainrpccookiefile=" + datadir + "/" + parent_chain + "/.cookie")
+
+            self.add_nodes(1, [extra_args], chain=["elementsregtest"])
+            self.start_node(1 + n)
+            self.log.info(f"Node {1 + n} started (sidechain: elementsd)")
+
+        # We only connect the same-chain nodes, so sync_all works correctly
+        self.connect_nodes(1, 2)
+        self.node_groups = [
+            [self.nodes[0]],
+            [self.nodes[1], self.nodes[2]],
+        ]
+        for node_group in self.node_groups:
+            self.sync_all(node_group)
+        self.log.info("Setting up network done")
+
+    def run_test(self):
+        self.import_deterministic_coinbase_privkeys()  # Create wallets for all nodes
+
+        parent = self.nodes[0]
+        sidechain = self.nodes[1]
+        sidechain2 = self.nodes[2]
+
+        assert_equal(sidechain.getsidechaininfo()["pegin_confirmation_depth"], 10)  # 10+2 confirms required to get into mempool and confirm
+
+        parent.importprivkey(privkey=parent.get_deterministic_priv_key().key, label="mining")
+        sidechain.importprivkey(privkey=sidechain.get_deterministic_priv_key().key, label="mining")
+        util.node_fastmerkle = sidechain
+
+        self.generate(parent, 101, sync_fun=self.no_op)
+        self.generate(sidechain, 101, sync_fun=self.no_op)
+
+        def sync_sidechain():
+            return self.sync_all([sidechain, sidechain2])
+
+        DEFAULT_FEERATE = 1.0
+
+        def parent_pegin(parent, node, amount=1.0, feerate=DEFAULT_FEERATE):
+            address = node.getpeginaddress()
+            mainchain_address, claim_script = (
+                address["mainchain_address"],
+                address["claim_script"],
+            )
+            txid = parent.sendtoaddress(address=mainchain_address, amount=amount, fee_rate=feerate)
+            vout = find_vout_for_address(parent, txid, mainchain_address)
+            self.generate(parent, 12, sync_fun=self.no_op)
+            txoutproof = parent.gettxoutproof([txid])
+            bitcoin_txhex = parent.gettransaction(txid)["hex"]
+            return (
+                txid,
+                vout,
+                txoutproof,
+                bitcoin_txhex,
+                claim_script,
+            )
+
+        self.log.info("check new fields for getpeginaddress and getsidechaininfo")
+        result = sidechain.getpeginaddress()
+        assert_equal(result["pegin_min_amount"], "1.00")
+        assert_equal(result["pegin_min_height"], PEGIN_MINIMUM_HEIGHT)
+        assert_equal(result["pegin_min_active"], False)
+        assert_equal(result["pegin_subsidy_threshold"], "2.00")
+        assert_equal(result["pegin_subsidy_height"], PEGIN_SUBSIDY_HEIGHT)
+        assert_equal(result["pegin_subsidy_active"], False)
+        result = sidechain.getsidechaininfo()
+        assert_equal(result["pegin_min_amount"], "1.00")
+        assert_equal(result["pegin_min_height"], PEGIN_MINIMUM_HEIGHT)
+        assert_equal(result["pegin_min_active"], False)
+        assert_equal(result["pegin_subsidy_threshold"], "2.00")
+        assert_equal(result["pegin_subsidy_height"], PEGIN_SUBSIDY_HEIGHT)
+        assert_equal(result["pegin_subsidy_active"], False)
+
+        self.log.info("check min pegin amount before minimum pegin height")
+        assert_equal(sidechain.getblockchaininfo()["blocks"], PEGIN_MINIMUM_HEIGHT - 1)
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, amount=0.5)
+        pegin_txid = sidechain.claimpegin(bitcoin_txhex, txoutproof, claim_script)
+        self.generate(sidechain, 1, sync_fun=sync_sidechain)
+        pegin_tx = sidechain.gettransaction(pegin_txid, True, True)
+        assert_equal(pegin_tx["confirmations"], 1)
+
+        assert_equal(sidechain.getblockchaininfo()["blocks"], PEGIN_MINIMUM_HEIGHT)
+        result = sidechain.getpeginaddress()
+        assert_equal(result["pegin_min_amount"], "1.00")
+        assert_equal(result["pegin_min_height"], PEGIN_MINIMUM_HEIGHT)
+        assert_equal(result["pegin_min_active"], True)
+        assert_equal(result["pegin_subsidy_threshold"], "2.00")
+        assert_equal(result["pegin_subsidy_height"], PEGIN_SUBSIDY_HEIGHT)
+        assert_equal(result["pegin_subsidy_active"], False)
+        result = sidechain.getsidechaininfo()
+        assert_equal(result["pegin_min_amount"], "1.00")
+        assert_equal(result["pegin_min_height"], PEGIN_MINIMUM_HEIGHT)
+        assert_equal(result["pegin_min_active"], True)
+        assert_equal(result["pegin_subsidy_threshold"], "2.00")
+        assert_equal(result["pegin_subsidy_height"], PEGIN_SUBSIDY_HEIGHT)
+        assert_equal(result["pegin_subsidy_active"], False)
+
+        self.log.info("check min pegin amount after minimum pegin height")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, amount=0.5)
+        assert_raises_rpc_error(
+            -4,
+            "Pegin amount (0.50) is lower than the minimum pegin amount for this chain (1.00).",
+            sidechain.claimpegin,
+            bitcoin_txhex,
+            txoutproof,
+            claim_script,
+        )
+        # check manually constructed
+        inputs = [
+            {
+                "txid": txid,
+                "vout": vout,
+                "pegin_bitcoin_tx": bitcoin_txhex,
+                "pegin_txout_proof": txoutproof,
+                "pegin_claim_script": claim_script,
+            },
+        ]
+        fee = Decimal("0.00000363")
+        outputs = [
+            {sidechain.getnewaddress(): Decimal("0.5") - fee},
+            {"fee": fee},
+        ]
+        raw = sidechain.createrawtransaction(inputs, outputs)
+        signed = sidechain.signrawtransactionwithwallet(raw)
+        assert_equal(signed["complete"], True)
+        accept = sidechain.testmempoolaccept([signed["hex"]])
+        assert_equal(accept[0]["allowed"], False)
+        assert_equal(accept[0]["reject-reason"], "pegin-value-too-low")
+
+        self.log.info("createrawpegin before enforcement, with validatepegin, below threshold")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, amount=1.0, feerate=2.0)
+        pegintx = sidechain.createrawpegin(bitcoin_txhex, txoutproof, claim_script)
+        signed = sidechain.signrawtransactionwithwallet(pegintx["hex"])
+        assert_equal(signed["complete"], True)
+        pegin_txid = sidechain.sendrawtransaction(signed["hex"])
+        pegin_tx = sidechain.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 2)
+        self.generate(sidechain, 1, sync_fun=sync_sidechain)
+
+        self.log.info("createrawpegin before enforcement, with validatepegin, above threshold")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, amount=2.0, feerate=2.0)
+        pegintx = sidechain.createrawpegin(bitcoin_txhex, txoutproof, claim_script)
+        signed = sidechain.signrawtransactionwithwallet(pegintx["hex"])
+        assert_equal(signed["complete"], True)
+        pegin_txid = sidechain.sendrawtransaction(signed["hex"])
+        pegin_tx = sidechain.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 2)
+        self.generate(sidechain, 1, sync_fun=sync_sidechain)
+
+        self.log.info("createrawpegin before enforcement, without validatepegin, below threshold")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain2, amount=1.0, feerate=2.0)
+        pegintx = sidechain2.createrawpegin(bitcoin_txhex, txoutproof, claim_script)
+        signed = sidechain2.signrawtransactionwithwallet(pegintx["hex"])
+        assert_equal(signed["complete"], True)
+        pegin_txid = sidechain2.sendrawtransaction(signed["hex"])
+        pegin_tx = sidechain2.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 2)
+        self.generate(sidechain2, 1, sync_fun=sync_sidechain)
+
+        self.log.info("createrawpegin before enforcement, without validatepegin, above threshold")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain2, amount=2.0, feerate=2.0)
+        pegintx = sidechain2.createrawpegin(bitcoin_txhex, txoutproof, claim_script)
+        signed = sidechain2.signrawtransactionwithwallet(pegintx["hex"])
+        assert_equal(signed["complete"], True)
+        pegin_txid = sidechain2.sendrawtransaction(signed["hex"])
+        pegin_tx = sidechain2.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 2)
+        self.generate(sidechain2, 1, sync_fun=sync_sidechain)
+
+        self.log.info("claimpegin before enforcement, with validatepegin, below threshold")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, amount=1.0, feerate=2.0)
+        pegin_txid = sidechain.claimpegin(bitcoin_txhex, txoutproof, claim_script)
+        pegin_tx = sidechain.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 2)
+        self.generate(sidechain, 1, sync_fun=sync_sidechain)
+
+        self.log.info("claimpegin before enforcement, with validatepegin, above threshold")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, amount=2.0, feerate=2.0)
+        pegin_txid = sidechain.claimpegin(bitcoin_txhex, txoutproof, claim_script)
+        pegin_tx = sidechain.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 2)
+        self.generate(sidechain, 1, sync_fun=sync_sidechain)
+
+        self.log.info("claimpegin before enforcement, without validatepegin, below threshold")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain2, amount=1.0, feerate=2.0)
+        pegin_txid = sidechain2.claimpegin(bitcoin_txhex, txoutproof, claim_script)
+        pegin_tx = sidechain2.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 2)
+        self.generate(sidechain2, 1, sync_fun=sync_sidechain)
+
+        self.log.info("claimpegin before enforcement, without validatepegin, above threshold")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain2, amount=2.0, feerate=2.0)
+        pegin_txid = sidechain2.claimpegin(bitcoin_txhex, txoutproof, claim_script)
+        pegin_tx = sidechain2.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 2)
+        self.generate(sidechain2, 1, sync_fun=sync_sidechain)
+
+        num = PEGIN_SUBSIDY_HEIGHT - sidechain.getblockchaininfo()["blocks"]
+        assert num > 0
+        self.generate(sidechain, num, sync_fun=sync_sidechain)
+
+        self.log.info(f"===== peg-in subsidy enforcement at height {PEGIN_SUBSIDY_HEIGHT} =====")
+        assert_equal(sidechain.getblockchaininfo()["blocks"], PEGIN_SUBSIDY_HEIGHT)
+
+        self.log.info("check new fields for getpeginaddress and getsidechaininfo")
+        result = sidechain.getpeginaddress()
+        assert_equal(result["pegin_min_amount"], "1.00")
+        assert_equal(result["pegin_min_height"], PEGIN_MINIMUM_HEIGHT)
+        assert_equal(result["pegin_min_active"], True)
+        assert_equal(result["pegin_subsidy_threshold"], "2.00")
+        assert_equal(result["pegin_subsidy_height"], PEGIN_SUBSIDY_HEIGHT)
+        assert_equal(result["pegin_subsidy_active"], True)
+        result = sidechain.getsidechaininfo()
+        assert_equal(result["pegin_min_amount"], "1.00")
+        assert_equal(result["pegin_min_height"], PEGIN_MINIMUM_HEIGHT)
+        assert_equal(result["pegin_min_active"], True)
+        assert_equal(result["pegin_subsidy_threshold"], "2.00")
+        assert_equal(result["pegin_subsidy_height"], PEGIN_SUBSIDY_HEIGHT)
+        assert_equal(result["pegin_subsidy_active"], True)
+
+        # blinded pegins
+        self.log.info("blinded pegin below threshold, with validatepegin, subsidy too low")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, amount=1.0, feerate=1.0)
+        addr = sidechain.getnewaddress(address_type="blech32")
+        utxo = sidechain.listunspent()[0]
+        changeaddr = sidechain.getrawchangeaddress(address_type="blech32")
+        inputs = [
+            {
+                "txid": txid,
+                "vout": vout,
+                "pegin_bitcoin_tx": bitcoin_txhex,
+                "pegin_txout_proof": txoutproof,
+                "pegin_claim_script": claim_script,
+            },
+            {
+                "txid": utxo["txid"],
+                "vout": utxo["vout"],
+            },
+        ]
+        fee = Decimal("0.00000363")
+        subsidy = Decimal("0.00000395")
+        outputs = [
+            {addr: Decimal("1.0") - fee - subsidy},
+            {changeaddr: utxo["amount"]},
+            {"burn": subsidy},
+            {"fee": fee},
+        ]
+        raw = sidechain.createrawtransaction(inputs, outputs)
+        blinded = sidechain.blindrawtransaction(hexstring=raw, ignoreblindfail=False)
+        signed = sidechain.signrawtransactionwithwallet(blinded)
+        assert_equal(signed["complete"], True)
+        # node 2 can't validatepegin but checks the minimum subsidy
+        accept = sidechain2.testmempoolaccept([signed["hex"]])
+        assert_equal(accept[0]["allowed"], False)
+        assert_equal(accept[0]["reject-reason"], "pegin-subsidy-too-low")
+        # node 1 will reject
+        accept = sidechain.testmempoolaccept([signed["hex"]])
+        assert_equal(accept[0]["allowed"], False)
+        assert_equal(accept[0]["reject-reason"], "pegin-subsidy-too-low")
+        assert_raises_rpc_error(
+            -26,
+            "pegin-subsidy-too-low",
+            sidechain.sendrawtransaction,
+            signed["hex"],
+        )
+
+        self.log.info("blinded pegin above threshold, with validatepegin")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, amount=2.0, feerate=1.0)
+        addr = sidechain.getnewaddress(address_type="blech32")
+        utxo = sidechain.listunspent()[0]
+        changeaddr = sidechain.getrawchangeaddress(address_type="blech32")
+        inputs = [
+            {
+                "txid": txid,
+                "vout": vout,
+                "pegin_bitcoin_tx": bitcoin_txhex,
+                "pegin_txout_proof": txoutproof,
+                "pegin_claim_script": claim_script,
+            },
+            {
+                "txid": utxo["txid"],
+                "vout": utxo["vout"],
+            },
+        ]
+        fee = Decimal("0.00000363")
+        outputs = [
+            {addr: Decimal("2.0") - fee},
+            {changeaddr: utxo["amount"]},
+            {"fee": fee},
+        ]
+        raw = sidechain.createrawtransaction(inputs, outputs)
+        blinded = sidechain.blindrawtransaction(hexstring=raw, ignoreblindfail=False)
+        signed = sidechain.signrawtransactionwithwallet(blinded)
+        assert_equal(signed["complete"], True)
+        accept = sidechain.testmempoolaccept([signed["hex"]])
+        assert_equal(accept[0]["allowed"], True)
+        # =======
+
+        self.log.info("createrawpegin after enforcement, with validatepegin, below threshold")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain)
+        pegintx = sidechain.createrawpegin(bitcoin_txhex, txoutproof, claim_script)
+        signed = sidechain.signrawtransactionwithwallet(pegintx["hex"])
+        pegin_txid = sidechain.sendrawtransaction(signed["hex"])
+        pegin_tx = sidechain.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 3)
+        # WSH input 41 bytes * 4 = 164 weight
+        # Witness (11 * 72 bytes signatures + 626 bytes script size) = 1418 weight
+        # (164 + 1418 + 3) / 4 = 396 vbytes
+        assert_equal(pegin_tx["decoded"]["vout"][1]["value"], Decimal("0.00000396"))
+        self.generate(sidechain, 1, sync_fun=sync_sidechain)
+
+        self.log.info("createrawpegin after enforcement, with validatepegin, above threshold")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, amount=3.0, feerate=2.0)
+        pegintx = sidechain.createrawpegin(bitcoin_txhex, txoutproof, claim_script)
+        signed = sidechain.signrawtransactionwithwallet(pegintx["hex"])
+        pegin_txid = sidechain.sendrawtransaction(signed["hex"])
+        pegin_tx = sidechain.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 2)
+        self.generate(sidechain, 1, sync_fun=sync_sidechain)
+
+        self.log.info("createrawpegin after enforcement, without validatepegin, below threshold")
+        feerate = 2.0
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain2, 1.0, feerate)
+        assert_raises_rpc_error(
+            -8,
+            "Bitcoin transaction fee rate must be supplied, because validatepegin is off and this peg-in requires a burn subsidy.",
+            sidechain2.createrawpegin,
+            bitcoin_txhex,
+            txoutproof,
+            claim_script,
+        )
+
+        pegintx = sidechain2.createrawpegin(bitcoin_txhex, txoutproof, claim_script, feerate)
+        signed = sidechain2.signrawtransactionwithwallet(pegintx["hex"])
+        pegin_txid = sidechain2.sendrawtransaction(signed["hex"])
+        pegin_tx = sidechain2.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 3)
+        assert_equal(pegin_tx["decoded"]["vout"][1]["value"], Decimal("0.00000792"))
+        self.generate(sidechain2, 1, sync_fun=sync_sidechain)
+
+        self.log.info("createrawpegin after enforcement, without validatepegin, above threshold")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain2, amount=2.0, feerate=2.0)
+        pegintx = sidechain2.createrawpegin(bitcoin_txhex, txoutproof, claim_script, feerate)
+        signed = sidechain2.signrawtransactionwithwallet(pegintx["hex"])
+        assert_equal(signed["complete"], True)
+        pegin_txid = sidechain2.sendrawtransaction(signed["hex"])
+        pegin_tx = sidechain2.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 2)
+        self.generate(sidechain2, 1, sync_fun=sync_sidechain)
+
+        self.log.info("claimpegin after enforcement, with validatepegin, below threshold")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, amount=1.0, feerate=2.0)
+        pegin_txid = sidechain.claimpegin(bitcoin_txhex, txoutproof, claim_script)
+        pegin_tx = sidechain.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 3)
+        assert_equal(pegin_tx["decoded"]["vout"][1]["value"], Decimal("0.00000792"))
+        self.generate(sidechain, 1, sync_fun=sync_sidechain)
+
+        self.log.info("claimpegin after enforcement, with validatepegin, above threshold")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, amount=2.0, feerate=2.0)
+        pegin_txid = sidechain.claimpegin(bitcoin_txhex, txoutproof, claim_script)
+        pegin_tx = sidechain.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 2)
+        self.generate(sidechain, 1, sync_fun=sync_sidechain)
+
+        self.log.info("claimpegin after enforcement, without validatepegin, below threshold")
+        feerate = 2.0
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain2, 1.0, feerate)
+        assert_raises_rpc_error(
+            -8,
+            "Bitcoin transaction fee rate must be supplied, because validatepegin is off and this peg-in requires a burn subsidy.",
+            sidechain2.claimpegin,
+            bitcoin_txhex,
+            txoutproof,
+            claim_script,
+        )
+
+        pegin_txid = sidechain2.claimpegin(bitcoin_txhex, txoutproof, claim_script, feerate)
+        pegin_tx = sidechain2.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 3)
+        assert_equal(pegin_tx["decoded"]["vout"][1]["value"], Decimal("0.00000792"))
+        self.generate(sidechain2, 1, sync_fun=sync_sidechain)
+
+        self.log.info("claimpegin after enforcement, without validatepegin, above threshold")
+        feerate = 2.0
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain2, 2.0, feerate)
+        pegin_txid = sidechain2.claimpegin(bitcoin_txhex, txoutproof, claim_script, feerate)
+        pegin_tx = sidechain2.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 2)
+        self.generate(sidechain2, 1, sync_fun=sync_sidechain)
+
+        self.log.info("claimpegin after enforcement, without validatepegin, below threshold, with incorrect subsidy output")
+        # should be accepted by sidechain2 but rejected by the node that is validating pegins
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain2, amount=1.0, feerate=2.0)
+        assert_raises_rpc_error(
+            -8,
+            "Bitcoin transaction fee rate must be supplied, because validatepegin is off and this peg-in requires a burn subsidy.",
+            sidechain2.claimpegin,
+            bitcoin_txhex,
+            txoutproof,
+            claim_script,
+        )
+
+        low_feerate = 1.0
+        pegin_txid = sidechain2.claimpegin(bitcoin_txhex, txoutproof, claim_script, low_feerate)
+        pegin_tx = sidechain2.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 3)
+
+        accept = sidechain.testmempoolaccept([pegin_tx["hex"]])
+        assert_equal(accept[0]["allowed"], False)
+        assert_equal(accept[0]["reject-reason"], "pegin-subsidy-too-low")
+        self.generate(sidechain2, 1, sync_fun=sync_sidechain)
+
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain2, amount=1.99999999, feerate=2.0)
+        assert_raises_rpc_error(
+            -8,
+            "Bitcoin transaction fee rate must be supplied, because validatepegin is off and this peg-in requires a burn subsidy.",
+            sidechain2.claimpegin,
+            bitcoin_txhex,
+            txoutproof,
+            claim_script,
+        )
+
+        low_feerate = 1.0
+        pegin_txid = sidechain2.claimpegin(bitcoin_txhex, txoutproof, claim_script, low_feerate)
+        pegin_tx = sidechain2.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 3)
+
+        accept = sidechain.testmempoolaccept([pegin_tx["hex"]])
+        assert_equal(accept[0]["allowed"], False)
+        assert_equal(accept[0]["reject-reason"], "pegin-subsidy-too-low")
+        self.generate(sidechain2, 1, sync_fun=sync_sidechain)
+
+        # sidechain2 should accept a 1 sat/vb subsidy for a higher feerate parent, but validating node should reject
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain2, amount=1.0, feerate=2.0)
+        # first try with less than 1 sat/vb subsidy
+        inputs = [
+            {
+                "txid": txid,
+                "vout": vout,
+                "pegin_bitcoin_tx": bitcoin_txhex,
+                "pegin_txout_proof": txoutproof,
+                "pegin_claim_script": claim_script,
+            },
+        ]
+        fee = Decimal("0.00000363")
+        addr = get_new_unconfidential_address(sidechain)
+        # subsidy less than 1 sat/vb
+        subsidy = Decimal("0.00000395")
+        outputs = [
+            {addr: Decimal("1.0") - fee - subsidy},
+            {"burn": subsidy},
+            {"fee": fee},
+        ]
+
+        raw = sidechain2.createrawtransaction(inputs, outputs)
+        signed = sidechain2.signrawtransactionwithwallet(raw)
+        assert_equal(signed["complete"], True)
+
+        accept = sidechain2.testmempoolaccept([signed["hex"]])
+        assert_equal(accept[0]["allowed"], False)
+        assert_equal(accept[0]["reject-reason"], "pegin-subsidy-too-low")
+
+        accept = sidechain.testmempoolaccept([signed["hex"]])
+        assert_equal(accept[0]["allowed"], False)
+        assert_equal(accept[0]["reject-reason"], "pegin-subsidy-too-low")
+
+        # subsidy for 1 sat/vb accepted by sidechain2, but rejected by validating node
+        subsidy = Decimal("0.00000396")
+        outputs = [
+            {addr: Decimal("1.0") - fee - subsidy},
+            {"burn": subsidy},
+            {"fee": fee},
+        ]
+
+        raw = sidechain2.createrawtransaction(inputs, outputs)
+        signed = sidechain2.signrawtransactionwithwallet(raw)
+        assert_equal(signed["complete"], True)
+
+        accept = sidechain2.testmempoolaccept([signed["hex"]])
+        assert_equal(accept[0]["allowed"], True)
+
+        accept = sidechain.testmempoolaccept([signed["hex"]])
+        assert_equal(accept[0]["allowed"], False)
+        assert_equal(accept[0]["reject-reason"], "pegin-subsidy-too-low")
+
+        # sub 1 sat/vb parent feerate should use 1 sat/vb for subsidy calculation
+        self.log.info("claimpegin after enforcement, with validatepegin, below threshold, sub 1 sat/vb parent")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, amount=1, feerate=0.1)
+        pegin_txid = sidechain.claimpegin(bitcoin_txhex, txoutproof, claim_script)
+        pegin_tx = sidechain.gettransaction(pegin_txid, True, True)
+        assert_equal(len(pegin_tx["decoded"]["vout"]), 3)
+        assert_equal(pegin_tx["decoded"]["vout"][1]["value"], Decimal("0.00000396"))
+
+        # check manually constructed pegin from a sub 1 sat/vb parent
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, amount=1, feerate=0.1)
+        inputs = [
+            {
+                "txid": txid,
+                "vout": vout,
+                "pegin_bitcoin_tx": bitcoin_txhex,
+                "pegin_txout_proof": txoutproof,
+                "pegin_claim_script": claim_script,
+            },
+        ]
+        fee = Decimal("0.00000363")
+        addr = get_new_unconfidential_address(sidechain)
+        # subsidy too low
+        subsidy = Decimal("0.00000395")
+        outputs = [
+            {addr: Decimal("1.0") - fee - subsidy},
+            {"burn": subsidy},
+            {"fee": fee},
+        ]
+
+        raw = sidechain.createrawtransaction(inputs, outputs)
+        signed = sidechain.signrawtransactionwithwallet(raw)
+        assert_equal(signed["complete"], True)
+        accept = sidechain.testmempoolaccept([signed["hex"]])
+        assert_equal(accept[0]["allowed"], False)
+        assert_equal(accept[0]["reject-reason"], "pegin-subsidy-too-low")
+
+        # subsidy accepted
+        subsidy = Decimal("0.00000396")
+        outputs = [
+            {addr: Decimal("1.0") - fee - subsidy},
+            {"burn": subsidy},
+            {"fee": fee},
+        ]
+
+        raw = sidechain.createrawtransaction(inputs, outputs)
+        signed = sidechain.signrawtransactionwithwallet(raw)
+        assert_equal(signed["complete"], True)
+        accept = sidechain.testmempoolaccept([signed["hex"]])
+        assert_equal(accept[0]["allowed"], True)
+        sidechain.sendrawtransaction(signed["hex"])
+        self.generate(sidechain, 1, sync_fun=sync_sidechain)
+        # =================================
+
+        self.log.info("construct a multi-pegin tx, below threshold")
+        feerate = 2.0
+        txid1, vout1, txoutproof1, bitcoin_txhex1, claim_script1 = parent_pegin(parent, sidechain, 0.5, feerate)
+        txid2, vout2, txoutproof2, bitcoin_txhex2, claim_script2 = parent_pegin(parent, sidechain, 1.0, feerate)
+
+        addr1 = get_new_unconfidential_address(sidechain)
+        addr2 = get_new_unconfidential_address(sidechain)
+
+        inputs = [
+            {
+                "txid": txid1,
+                "vout": vout1,
+                "pegin_bitcoin_tx": bitcoin_txhex1,
+                "pegin_txout_proof": txoutproof1,
+                "pegin_claim_script": claim_script1,
+            },
+            {
+                "txid": txid2,
+                "vout": vout2,
+                "pegin_bitcoin_tx": bitcoin_txhex2,
+                "pegin_txout_proof": txoutproof2,
+                "pegin_claim_script": claim_script2,
+            },
+        ]
+        fee = Decimal("0.00000363")
+        subsidy = Decimal("0.00001583")
+        outputs = [
+            {addr1: Decimal("0.5") - fee - subsidy},
+            {addr2: 1.0},
+            {"burn": subsidy},
+            {"fee": fee},
+        ]
+        raw = sidechain.createrawtransaction(inputs, outputs)
+        signed = sidechain.signrawtransactionwithwallet(raw)
+        assert_equal(signed["complete"], True)
+        accept = sidechain.testmempoolaccept([signed["hex"]])
+        assert_equal(accept[0]["allowed"], False)
+        assert_equal(accept[0]["reject-reason"], "pegin-subsidy-too-low")
+
+        subsidy = Decimal("0.00001584")
+        outputs = [
+            {addr1: Decimal("0.5") - fee - subsidy},
+            {addr2: 1.0},
+            {"burn": subsidy},
+            {"fee": fee},
+        ]
+        raw = sidechain.createrawtransaction(inputs, outputs)
+        signed = sidechain.signrawtransactionwithwallet(raw)
+        assert_equal(signed["complete"], True)
+        accept = sidechain.testmempoolaccept([signed["hex"]])
+        assert_equal(accept[0]["allowed"], True)
+        sidechain.sendrawtransaction(signed["hex"])
+        self.generate(sidechain2, 1, sync_fun=sync_sidechain)
+
+        self.log.info("construct a multi-pegin tx, above threshold")
+        txid1, vout1, txoutproof1, bitcoin_txhex1, claim_script1 = parent_pegin(parent, sidechain, amount=0.5, feerate=1.0)
+        txid2, vout2, txoutproof2, bitcoin_txhex2, claim_script2 = parent_pegin(parent, sidechain, amount=1.5, feerate=2.0)
+        addr1 = get_new_unconfidential_address(sidechain)
+        addr2 = get_new_unconfidential_address(sidechain)
+
+        inputs = [
+            {
+                "txid": txid1,
+                "vout": vout1,
+                "pegin_bitcoin_tx": bitcoin_txhex1,
+                "pegin_txout_proof": txoutproof1,
+                "pegin_claim_script": claim_script1,
+            },
+            {
+                "txid": txid2,
+                "vout": vout2,
+                "pegin_bitcoin_tx": bitcoin_txhex2,
+                "pegin_txout_proof": txoutproof2,
+                "pegin_claim_script": claim_script2,
+            },
+        ]
+        fee = Decimal("0.00000363")
+        outputs = [
+            {addr1: 0.5},
+            {addr2: Decimal("1.5") - fee},
+            {"fee": fee},
+        ]
+        raw = sidechain.createrawtransaction(inputs, outputs)
+        signed = sidechain.signrawtransactionwithwallet(raw)
+        accept = sidechain.testmempoolaccept([signed["hex"]])
+        assert_equal(accept[0]["allowed"], True)
+        sidechain.sendrawtransaction(signed["hex"])
+        self.generate(sidechain2, 1, sync_fun=sync_sidechain)
+
+        # minimum pegin amount is 1.0
+        self.log.info("claimpegin below minimum pegin amount")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, amount=0.99999999)
+        assert_raises_rpc_error(
+            -4,
+            "Pegin amount (0.99999999) is lower than the minimum pegin amount for this chain (1.00).",
+            sidechain2.claimpegin,
+            bitcoin_txhex,
+            txoutproof,
+            claim_script,
+        )
+
+        # check minimum pegin amount in mempool validation by constructing manually
+        self.log.info("rawtransaction below minimum pegin amount")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain2, amount=0.99999999)
+        addr = sidechain2.getnewaddress()
+        inputs = [
+            {
+                "txid": txid,
+                "vout": vout,
+                "pegin_bitcoin_tx": bitcoin_txhex,
+                "pegin_txout_proof": txoutproof,
+                "pegin_claim_script": claim_script,
+            },
+        ]
+        fee = Decimal("0.00000363")
+        subsidy = Decimal("0.00000396")
+        outputs = [
+            {addr: Decimal("0.99999999") - fee - subsidy},
+            {"burn": subsidy},
+            {"fee": fee},
+        ]
+
+        raw = sidechain2.createrawtransaction(inputs, outputs)
+        signed = sidechain2.signrawtransactionwithwallet(raw)
+        assert_equal(signed["complete"], True)
+        accept = sidechain2.testmempoolaccept([signed["hex"]])
+        # node2 can check the min pegin amount as the pegin amount is in the witness
+        assert_equal(accept[0]["allowed"], False)
+        assert_equal(accept[0]["reject-reason"], "pegin-value-too-low")
+        # node1 rejects below the min pegin amount with validatepegin
+        accept = sidechain.testmempoolaccept([signed["hex"]])
+        assert_equal(accept[0]["allowed"], False)
+        assert_equal(accept[0]["reject-reason"], "pegin-value-too-low")
+        assert_raises_rpc_error(
+            -26,
+            "pegin-value-too-low",
+            sidechain.sendrawtransaction,
+            signed["hex"],
+        )
+        self.generate(sidechain, 1, sync_fun=sync_sidechain)
+
+        # test various feerates
+        self.log.info("claimpegin with validatepegin, below threshold, at various feerates")
+        for feerate in [1.0, 1.5, 2.0, 2.3, 3.9, 4.6, 5.2, 6.1, 10.01, 20.7, 22.22, 24.18]:
+            txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, 1.0, feerate)
+            pegin_txid = sidechain.claimpegin(bitcoin_txhex, txoutproof, claim_script)
+            pegin_tx = sidechain.gettransaction(pegin_txid, True, True)
+            assert_equal(len(pegin_tx["decoded"]["vout"]), 3)
+            self.generate(sidechain, 1, sync_fun=sync_sidechain)
+
+        # dust error
+        # restart node1 with no min pegin amount
+        self.stop_node(1, expected_stderr=self.expected_stderr)  # when running with bitcoind as parent node this stderr can occur
+        self.start_node(1, extra_args=sidechain.extra_args + ["-peginminamount=0"])
+        self.log.info("claimpegin dust error")
+        amount = Decimal("0.00000546") if self.options.parent_bitcoin else Decimal("0.00000645")
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain, amount)
+        assert_raises_rpc_error(
+            -4,
+            "Peg-in transaction would create dust output.",
+            sidechain.claimpegin,
+            bitcoin_txhex,
+            txoutproof,
+            claim_script,
+        )
+        # check dust mempool validation by constructing manually
+        txid, vout, txoutproof, bitcoin_txhex, claim_script = parent_pegin(parent, sidechain2, amount=0.00001570)
+        addr = sidechain2.getnewaddress()
+        inputs = [
+            {
+                "txid": txid,
+                "vout": vout,
+                "pegin_bitcoin_tx": bitcoin_txhex,
+                "pegin_txout_proof": txoutproof,
+                "pegin_claim_script": claim_script,
+            },
+        ]
+        fee = Decimal("0.00000363")
+        subsidy = Decimal("0.00001194")
+        outputs = [
+            {addr: Decimal("0.00001570") - fee - subsidy},  # 14 sats is dust at 0.1 sat/vb dustrelayfee
+            {"burn": subsidy},
+            {"fee": fee},
+        ]
+
+        raw = sidechain2.createrawtransaction(inputs, outputs)
+        signed = sidechain2.signrawtransactionwithwallet(raw)
+        assert_equal(signed["complete"], True)
+        accept = sidechain2.testmempoolaccept([signed["hex"]])
+        # mempool validation already checks for dust outputs
+        assert_equal(accept[0]["allowed"], False)
+        assert_equal(accept[0]["reject-reason"], "dust")
+        accept = sidechain.testmempoolaccept([signed["hex"]])
+        assert_equal(accept[0]["allowed"], False)
+        assert_equal(accept[0]["reject-reason"], "dust")
+        assert_raises_rpc_error(
+            -26,
+            "dust",
+            sidechain.sendrawtransaction,
+            signed["hex"],
+        )
+
+        # Manually stop sidechains first, then the parent chain.
+        self.stop_node(2)
+        self.stop_node(1, expected_stderr=self.expected_stderr)  # when running with bitcoind as parent node this stderr can occur
+        self.stop_node(0)
+
+
+if __name__ == "__main__":
+    PeginSubsidyTest().main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 3ff2738016..cba1d3edcf 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -191,6 +191,7 @@
     # ELEMENTS: discounted Confidential Transactions
     'feature_discount_ct.py',
     'feature_discount_ct_ordering.py',
+    'feature_pegin_subsidy.py --legacy-wallet',
     'wallet_multiwallet.py --legacy-wallet',
     'wallet_multiwallet.py --descriptors',
     'wallet_multiwallet.py --usecli',