diff --git a/src/policy/policy.cpp b/src/policy/policy.cpp
index 7e9ae8e99a8b..61e3b9104f71 100644
--- a/src/policy/policy.cpp
+++ b/src/policy/policy.cpp
@@ -340,12 +340,12 @@ bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
             }
         }
 
-        // Check policy limits for P2MR spends:
+        // Check policy limits for native P2MR spends:
         // - MAX_STANDARD_P2MR_STACK_ITEM_SIZE limit for stack item size
         // - Script path only (no key path spending)
         // - No annexes
-        if (witnessversion == 2 && witnessprogram.size() == WITNESS_V2_P2MR_SIZE) {
-            // P2MR spend (non-P2SH-wrapped, version 3, witness program size 32)
+        if (witnessversion == 2 && witnessprogram.size() == WITNESS_V2_P2MR_SIZE && !p2sh) {
+            // P2MR spend (native witness v2, witness program size 32)
             std::span stack{tx.vin[i].scriptWitness.stack};
             if (stack.size() >= 2 && !stack.back().empty() && stack.back()[0] == ANNEX_TAG) {
                 // Annexes are nonstandard as long as no semantics are defined for them.
@@ -359,13 +359,7 @@ bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
                 if ((control_block[0] & TAPROOT_LEAF_MASK) == TAPROOT_LEAF_TAPSCRIPT) {
                     // Leaf version 0xc0 (aka Tapscript, see BIP 342)
                     for (const auto& item : stack) {
-                        // Allow larger items for SLH-DSA signatures (OP_SUCCESS127)
-                        if (item.size() > MAX_STANDARD_P2MR_STACK_ITEM_SIZE) {
-                            // Check if this is an SLH-DSA signature by looking at the script
-                            // You'd need to parse the script to see if it contains OP_SUCCESS127
-                            // For now, we could allow larger items when OP_SUCCESS127 is present
-                            return false; // Keep existing behavior until SLH-DSA is implemented
-                        }
+                        if (item.size() > MAX_STANDARD_P2MR_STACK_ITEM_SIZE) return false;
                     }
                 }
             } else {
diff --git a/src/policy/policy.h b/src/policy/policy.h
index 78a21ef81e7c..421905615693 100644
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -52,8 +52,8 @@ static constexpr unsigned int MAX_STANDARD_P2WSH_STACK_ITEMS{100};
 static constexpr unsigned int MAX_STANDARD_P2WSH_STACK_ITEM_SIZE{80};
 /** The maximum size in bytes of each witness stack item in a standard BIP 342 script (Taproot, leaf version 0xc0) */
 static constexpr unsigned int MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE{80};
-/** The maximum size in bytes of each witness stack item in a standard P2MR script */
-static constexpr unsigned int MAX_STANDARD_P2MR_STACK_ITEM_SIZE{8000};
+/** The maximum size in bytes of each witness stack item in a standard BIP 360 script */
+static constexpr unsigned int MAX_STANDARD_P2MR_STACK_ITEM_SIZE{80};
 /** The maximum size in bytes of a standard witnessScript */
 static constexpr unsigned int MAX_STANDARD_P2WSH_SCRIPT_SIZE{3600};
 /** The maximum size of a standard ScriptSig */
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
index 7e6588b216d0..96fe35af1925 100644
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -1631,7 +1631,7 @@ class P2MRDescriptor final : public DescriptorImpl
         uint256 merkle_root = builder.GetSpendData().merkle_root;
         
         CScript output_script;
-        output_script << OP_3 << ToByteVector(merkle_root);
+        output_script << OP_2 << ToByteVector(merkle_root);
         
         return {output_script};
     }
diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
index 9b88d4a8ab18..da13ecc1aa35 100644
--- a/src/script/interpreter.cpp
+++ b/src/script/interpreter.cpp
@@ -9,13 +9,9 @@
 #include <crypto/sha1.h>
 #include <crypto/sha256.h>
 #include <cstring>
-#include <logging.h>
 #include <pubkey.h>
 #include <script/script.h>
 #include <uint256.h>
-#include <util/strencodings.h>
-#include <libbitcoinpqc/bitcoinpqc.h>
-#include <libbitcoinpqc/slh_dsa.h>
 
 typedef std::vector<unsigned char> valtype;
 
@@ -220,16 +216,11 @@ bool CheckSignatureEncoding(const std::vector<unsigned char> &vchSig, unsigned i
 }
 
 bool static CheckPubKeyEncoding(const valtype &vchPubKey, unsigned int flags, const SigVersion &sigversion, ScriptError* serror) {
-    LogPrintf("SLH-DSA DEBUG: CheckPubKeyEncoding called with pubkey size=%zu, sigversion=%d, flags=0x%x\n", 
-             vchPubKey.size(), (int)sigversion, flags);
-    
     if ((flags & SCRIPT_VERIFY_STRICTENC) != 0 && !IsCompressedOrUncompressedPubKey(vchPubKey)) {
-        LogPrintf("SLH-DSA DEBUG: CheckPubKeyEncoding failed STRICTENC check for %zu-byte pubkey\n", vchPubKey.size());
         return set_error(serror, SCRIPT_ERR_PUBKEYTYPE);
     }
     // Only compressed keys are accepted in segwit
     if ((flags & SCRIPT_VERIFY_WITNESS_PUBKEYTYPE) != 0 && sigversion == SigVersion::WITNESS_V0 && !IsCompressedPubKey(vchPubKey)) {
-        LogPrintf("SLH-DSA DEBUG: CheckPubKeyEncoding failed WITNESS_PUBKEYTYPE check for %zu-byte pubkey\n", vchPubKey.size());
         return set_error(serror, SCRIPT_ERR_WITNESS_PUBKEYTYPE);
     }
     return true;
@@ -1793,403 +1784,38 @@ bool GenericTransactionSignatureChecker<T>::CheckSequence(const CScriptNum& nSeq
     return true;
 }
 
-// Helper function to create message hash for SLH-DSA using the same approach as Schnorr
-template<typename T>
-static bool CreateSLHDSAMessageHash(uint256& hash_out, ScriptExecutionData& execdata, const T& tx_to, uint32_t in_pos, uint8_t hash_type, const PrecomputedTransactionData& cache, MissingDataBehavior mdb)
-{
-    // For SLH-DSA in Tapscript context, we use the same sighash construction
-    // as Schnorr signatures in Tapscript (BIP 341)
-    
-    // We can reuse the existing SignatureHashSchnorr function since it implements
-    // the correct BIP 341 Tapscript sighash construction
-    return SignatureHashSchnorr(hash_out, execdata, tx_to, in_pos, hash_type, SigVersion::TAPSCRIPT, cache, mdb);
-}
-
-// Handle SLH-DSA signature verification for OP_SUCCESS127
-template<typename T>
-static bool HandleSLHDSASignature(std::vector<valtype>& stack, const CScript& exec_script, unsigned int flags, const GenericTransactionSignatureChecker<T>& checker, ScriptExecutionData& execdata, ScriptError* serror)
-{
-    LogPrintf("SLH-DSA DEBUG: HandleSLHDSASignature called with stack size %zu, script size %zu\n", stack.size(), exec_script.size());
-    
-    // Add comparison debugging for different script formats
-    LogPrintf("SLH-DSA DEBUG: ===== SCRIPT FORMAT COMPARISON =====\n");
-    LogPrintf("SLH-DSA DEBUG: Current script size: %zu\n", exec_script.size());
-    if (exec_script.size() == 70) {
-        LogPrintf("SLH-DSA DEBUG: This is COMBINED format - comparing with SLH_DSA_ONLY behavior\n");
-    } else if (exec_script.size() == 34) {
-        LogPrintf("SLH-DSA DEBUG: This is SIMPLE format - should work like SLH_DSA_ONLY\n");
-    }
-    LogPrintf("SLH-DSA DEBUG: ===== END SCRIPT FORMAT COMPARISON =====\n");
-    
-    valtype signature;
-    valtype pubkey;
-    
-    // Support two script formats:
-    // Format 1 (simple): <32-byte-pubkey> OP_RESERVED (34 bytes)
-    // Format 2 (combined): <SCHNORR Pub Key> OP_CHECKSIG <SLH-DSA pub key> OP_SUBSTR OP_BOOLAND OP_VERIFY (70 bytes)
-    
-    if (exec_script.size() == 34) {
-        // Format 1: Simple SLH-DSA only script
-        LogPrintf("SLH-DSA DEBUG: Detected simple SLH-DSA script format (34 bytes)\n");
-        
-        if (stack.size() != 1) {
-            LogPrintf("SLH-DSA DEBUG: Expected stack size 1 for simple format, got %zu\n", stack.size());
-            return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
-        }
-        
-        signature = stack[0];
-        // Extract the 32-byte public key from the script (skip the OP_PUSHBYTES_32 opcode)
-        pubkey = valtype(exec_script.begin() + 1, exec_script.begin() + 33);
-        
-    } else if (exec_script.size() == 70) {
-        // Format 2: Combined Schnorr + SLH-DSA script
-        LogPrintf("SLH-DSA DEBUG: Detected combined Schnorr+SLH-DSA script format (70 bytes)\n");
-        
-        // Add detailed script format debugging
-        LogPrintf("SLH-DSA DEBUG: ===== SCRIPT FORMAT ANALYSIS =====\n");
-        LogPrintf("SLH-DSA DEBUG: Script size: %zu bytes\n", exec_script.size());
-        
-        LogPrintf("SLH-DSA DEBUG: Combined script format detected\n");
-        LogPrintf("SLH-DSA DEBUG: Schnorr pubkey (bytes 1-32): %s\n", HexStr(std::span<const uint8_t>(exec_script.begin() + 1, 32)).c_str());
-        
-        LogPrintf("SLH-DSA DEBUG: SLH-DSA pubkey (bytes 35-66): %s\n", HexStr(std::span<const uint8_t>(exec_script.begin() + 35, 32)).c_str());
-        LogPrintf("SLH-DSA DEBUG: ===== END SCRIPT FORMAT ANALYSIS =====\n");
-        
-        if (stack.size() == 1 && stack[0].size() == 7922) {
-            // Combined witness element: [schnorr_sig(64) + sighash(1) + slh_dsa_sig(7856) + sighash(1)]
-            LogPrintf("SLH-DSA DEBUG: Combined witness element detected, size: %zu\n", stack[0].size());
-            
-            valtype combined_sig = stack[0];
-            
-            // Extract Schnorr signature (first 64 bytes)
-            valtype schnorr_sig = valtype(combined_sig.begin(), combined_sig.begin() + 64);
-            LogPrintf("SLH-DSA DEBUG: Extracted Schnorr signature, size: %zu\n", schnorr_sig.size());
-            
-            // Extract SLH-DSA signature (skip schnorr + sighash, get next 7856 bytes)
-            valtype slh_dsa_sig = valtype(combined_sig.begin() + 65, combined_sig.begin() + 65 + 7856);
-            LogPrintf("SLH-DSA DEBUG: Extracted SLH-DSA signature, size: %zu\n", slh_dsa_sig.size());
-            
-            // Use the extracted SLH-DSA signature for verification
-            signature = slh_dsa_sig;
-            
-            LogPrintf("SLH-DSA DEBUG: Using extracted SLH-DSA signature for verification\n");
-        } else if (stack.size() == 2 && stack[0].size() == 64 && stack[1].size() == 7856) {
-            // Legacy format: [schnorr_sig, slh_dsa_sig]
-            LogPrintf("SLH-DSA DEBUG: Legacy format detected, using SLH-DSA signature from stack[1]\n");
-            signature = stack[1];
-        } else if (stack.size() >= 3) {
-            // Post-OP_CHECKSIG state: [slh_dsa_pubkey, schnorr_result, slh_dsa_sig, ...]
-            LogPrintf("SLH-DSA DEBUG: Post-OP_CHECKSIG state detected\n");
-            
-            // Check if Schnorr verification succeeded (stack[1])
-            if (stack[1].size() != 1 || stack[1][0] != 1) {
-                LogPrintf("SLH-DSA DEBUG: Schnorr verification failed, cannot proceed with SLH-DSA\n");
-                return set_error(serror, SCRIPT_ERR_SLHDSA_SIG);
-            }
-            
-        // Get SLH-DSA signature from stack[2]
-        signature = stack[2];
-        LogPrintf("SLH-DSA DEBUG: Using SLH-DSA signature from stack[2], size: %zu\n", signature.size());
-        
-        // Add detailed stack state debugging
-        LogPrintf("SLH-DSA DEBUG: ===== STACK STATE ANALYSIS =====\n");
-        LogPrintf("SLH-DSA DEBUG: Stack size: %zu\n", stack.size());
-        for (size_t i = 0; i < stack.size(); i++) {
-            LogPrintf("SLH-DSA DEBUG: Stack[%zu]: size=%zu, first_16_bytes=%s\n", 
-                      i, stack[i].size(), 
-                      HexStr(std::span<const uint8_t>(stack[i].data(), std::min(stack[i].size(), (size_t)16))).c_str());
-        }
-        LogPrintf("SLH-DSA DEBUG: ===== END STACK STATE ANALYSIS =====\n");
-        } else {
-            LogPrintf("SLH-DSA DEBUG: Unexpected stack state for combined format, size: %zu\n", stack.size());
-            return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
-        }
-        
-        // Extract SLH-DSA public key from the combined script
-        // Script format: OP_PUSHBYTES_32 <schnorr_pubkey> OP_CHECKSIG OP_PUSHBYTES_32 <slh_dsa_pubkey> OP_SUBSTR OP_BOOLAND OP_VERIFY
-        // SLH-DSA pubkey is at bytes 35-66 (after OP_PUSHBYTES_32 + 32-byte schnorr pubkey + OP_CHECKSIG + OP_PUSHBYTES_32)
-        if (exec_script[34] != 0x20) {  // Check for OP_PUSHBYTES_32 before SLH-DSA pubkey
-            LogPrintf("SLH-DSA DEBUG: Invalid script format, expected OP_PUSHBYTES_32 at position 34\n");
-            return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
-        }
-        
-        pubkey = valtype(exec_script.begin() + 35, exec_script.begin() + 67);
-        LogPrintf("SLH-DSA DEBUG: Extracted SLH-DSA pubkey from combined script\n");
-        
-    } else {
-        LogPrintf("SLH-DSA DEBUG: Invalid script size %zu, expected 34 (simple) or 70 (combined)\n", exec_script.size());
-        return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
-    }
-    
-    LogPrintf("SLH-DSA DEBUG: signature size=%zu, pubkey size=%zu\n", signature.size(), pubkey.size());
-    
-    // Validate signature size (SLH-DSA signatures are 7856 bytes)
-    if (signature.size() < 100) {
-        LogPrintf("SLH-DSA DEBUG: Invalid signature size %zu, expected >= 100\n", signature.size());
-        return set_error(serror, SCRIPT_ERR_SLHDSA_SIG_SIZE);
-    }
-    
-    // Extract hash type from signature (similar to Schnorr signatures)
-    uint8_t hashtype = SIGHASH_DEFAULT;
-    size_t sig_size = signature.size();
-    
-    // Handle potential signature size mismatch (7857 vs 7856 bytes)
-    // The extra byte is the hash type byte (similar to Schnorr)
-    if (sig_size == 7857) {
-        // Extract hash type from the last byte
-        hashtype = signature[sig_size - 1];
-        LogPrintf("SLH-DSA DEBUG: Extracted hash type from signature: 0x%02x (%u)\n", 
-                  hashtype, hashtype);
-        
-        sig_size = 7856;  // Strip the hash type byte
-        LogPrintf("SLH-DSA DEBUG: Stripping hash type byte from signature (7857 -> 7856 bytes)\n");
-    } else if (exec_script.size() == 70) {
-        // For P2MR combined Schnorr+SLH-DSA scripts (70 bytes), use SIGHASH_ALL
-        // This matches the behavior of the Rust implementation
-        hashtype = SIGHASH_ALL;
-        LogPrintf("SLH-DSA DEBUG: P2MR combined script detected, using SIGHASH_ALL (0x%02x)\n", hashtype);
-    }
-    
-    // Create message hash for SLH-DSA verification using the extracted hash type
-    uint256 message_hash;
-    
-    // Ensure execdata is properly initialized for SignatureHashSchnorr
-    if (!execdata.m_codeseparator_pos_init) {
-        execdata.m_codeseparator_pos = 0xFFFFFFFFUL;
-        execdata.m_codeseparator_pos_init = true;
-    }
-    
-    // Create the message hash using the extracted hash type (same as Schnorr signatures)
-    if (!CreateSLHDSAMessageHash(message_hash, execdata, *checker.txTo, checker.nIn, hashtype, *checker.txdata, checker.m_mdb)) {
-        LogPrintf("SLH-DSA DEBUG: Failed to create message hash with hashtype 0x%02x\n", hashtype);
-        return set_error(serror, SCRIPT_ERR_SLHDSA_SIG);
-    }
-    
-    LogPrintf("SLH-DSA DEBUG: Created message hash with hashtype 0x%02x: %s\n", 
-              hashtype, message_hash.ToString().c_str());
-    
-    // Add comprehensive debugging
-    LogPrintf("SLH-DSA DEBUG: ===== DETAILED DEBUGGING =====\n");
-    LogPrintf("SLH-DSA DEBUG: Script size: %zu bytes\n", exec_script.size());
-    LogPrintf("SLH-DSA DEBUG: Stack size: %zu\n", stack.size());
-    LogPrintf("SLH-DSA DEBUG: Flags: 0x%x\n", flags);
-    
-    // Debug the exact message being hashed
-    LogPrintf("SLH-DSA DEBUG: Message hash bytes (hex): %s\n", HexStr(message_hash).c_str());
-    
-    // Debug signature details
-    LogPrintf("SLH-DSA DEBUG: Signature bytes (first 32): %s\n", 
-              HexStr(std::span<const uint8_t>(signature.begin(), std::min(signature.size(), (size_t)32))).c_str());
-    
-    // Debug public key details
-    LogPrintf("SLH-DSA DEBUG: Public key bytes (hex): %s\n", HexStr(pubkey).c_str());
-    
-    LogPrintf("SLH-DSA DEBUG: ===== END DETAILED DEBUGGING =====\n");
-    
-    LogPrintf("SLH-DSA DEBUG: Using algorithm BITCOIN_PQC_SLH_DSA_SHAKE_128S\n");
-    LogPrintf("SLH-DSA DEBUG: Full Pubkey: %s\n", HexStr(pubkey).c_str());
-    LogPrintf("SLH-DSA DEBUG: Full Message hash (sighash): %s\n", HexStr(message_hash).c_str());
-    LogPrintf("SLH-DSA DEBUG: Signature (first 16 bytes): %s\n", HexStr(std::span<const uint8_t>(signature.data(), 16)).c_str());
-    LogPrintf("SLH-DSA DEBUG: Signature (last 16 bytes): %s\n", HexStr(std::span<const uint8_t>(signature.data() + signature.size() - 16, 16)).c_str());
-    
-    // Debug: Check sizes match library expectations
-    LogPrintf("SLH-DSA DEBUG: Pubkey size: %zu bytes (expected: 32)\n", pubkey.size());
-    LogPrintf("SLH-DSA DEBUG: Signature size: %zu bytes (expected: 7856)\n", signature.size());
-    LogPrintf("SLH-DSA DEBUG: Message hash size: %zu bytes (expected: 32)\n", message_hash.size());
-    
-    // Add transaction context debugging
-    LogPrintf("SLH-DSA DEBUG: ===== TRANSACTION CONTEXT =====\n");
-    LogPrintf("SLH-DSA DEBUG: Hashtype: 0x%02x\n", hashtype);
-    LogPrintf("SLH-DSA DEBUG: Message hash size: %zu\n", message_hash.size());
-    LogPrintf("SLH-DSA DEBUG: Message hash (reversed for display): %s\n", HexStr(message_hash).c_str());
-
-    // Debug the exact bytes being passed to slh_dsa_shake_128s_verify
-    LogPrintf("SLH-DSA DEBUG: About to call slh_dsa_shake_128s_verify with:\n");
-    LogPrintf("SLH-DSA DEBUG: - Signature: %s...%s\n", 
-          HexStr(std::span<const uint8_t>(signature.data(), 16)).c_str(),
-          HexStr(std::span<const uint8_t>(signature.data() + signature.size() - 16, 16)).c_str());
-    LogPrintf("SLH-DSA DEBUG: - Public key: %s\n", HexStr(pubkey).c_str());
-    LogPrintf("SLH-DSA DEBUG: - Message hash: %s\n", HexStr(message_hash).c_str());
-    LogPrintf("SLH-DSA DEBUG: ===== END TRANSACTION CONTEXT =====\n");
-    
-    // Use the low-level SLH-DSA function directly (matches our 32-byte pubkeys and 7856-byte signatures)
-    int result = slh_dsa_shake_128s_verify(
-        signature.data(),
-        sig_size,
-        message_hash.begin(),
-        message_hash.size(),
-        pubkey.data()
-    );
-    
-    LogPrintf("SLH-DSA DEBUG: slh_dsa_shake_128s_verify returned: %d\n", result);
-    
-    if (result != 0) {
-        LogPrintf("SLH-DSA DEBUG: SLH-DSA signature verification failed with error %d\n", result);
-        return set_error(serror, SCRIPT_ERR_SLHDSA_SIG);
-    }
-    
-    LogPrintf("SLH-DSA DEBUG: SLH-DSA signature verification successful!\n");
-    
-    // Handle stack based on script format
-    if (exec_script.size() == 34) {
-        // Simple format: clear stack and push success
-        stack.clear();
-        stack.emplace_back(1, 1); // success
-    } else if (exec_script.size() == 70) {
-        // Combined format: handle both pre and post OP_CHECKSIG states
-        if (stack.size() == 2 && stack[0].size() == 64 && stack[1].size() == 7856) {
-            // Pre-OP_CHECKSIG state: [schnorr_sig, slh_dsa_sig] -> [schnorr_sig, slh_dsa_result]
-            stack[1] = valtype(1, 1); // Replace SLH-DSA signature with success result
-        } else if (stack.size() >= 3) {
-            // Post-OP_CHECKSIG state: [slh_dsa_pubkey, schnorr_result, slh_dsa_sig, ...] -> [slh_dsa_pubkey, schnorr_result, slh_dsa_result, ...]
-            stack[2] = valtype(1, 1); // Replace SLH-DSA signature with success result
-        } else {
-            LogPrintf("SLH-DSA DEBUG: Unexpected stack size %zu for combined format\n", stack.size());
-        }
-    }
-    
-    return set_success(serror);
-}
-
 // explicit instantiation
 template class GenericTransactionSignatureChecker<CTransaction>;
 template class GenericTransactionSignatureChecker<CMutableTransaction>;
 
 static bool ExecuteWitnessScript(const std::span<const valtype>& stack_span, const CScript& exec_script, unsigned int flags, SigVersion sigversion, const BaseSignatureChecker& checker, ScriptExecutionData& execdata, ScriptError* serror)
 {
-    LogPrintf("SLH-DSA DEBUG: ExecuteWitnessScript called with sigversion=%d, script size=%zu\n", (int)sigversion, exec_script.size());
     std::vector<valtype> stack{stack_span.begin(), stack_span.end()};
 
     if (sigversion == SigVersion::TAPSCRIPT) {
         // OP_SUCCESSx processing overrides everything, including stack element size limits
         CScript::const_iterator pc = exec_script.begin();
-        bool found_op_success127 = false;
         while (pc < exec_script.end()) {
             opcodetype opcode;
             if (!exec_script.GetOp(pc, opcode)) {
                 // Note how this condition would not be reached if an unknown OP_SUCCESSx was found
                 return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
             }
-            LogPrintf("SLH-DSA DEBUG: Processing opcode %d (0x%02x), IsOpSuccess=%d\n", opcode, opcode, IsOpSuccess(opcode));
             // New opcodes will be listed here. May use a different sigversion to modify existing opcodes.
             if (IsOpSuccess(opcode)) {
-                // Handle OP_SUCCESS127 for SLH-DSA signatures
-                if (opcode == OP_SUBSTR) {
-                    LogPrintf("SLH-DSA DEBUG: Found OP_SUBSTR (OP_SUCCESS127), checking for SLH-DSA signature\n");
-                    
-                    // Check for combined script format (70 bytes) or simple format (34 bytes)
-                    bool is_combined_format = (exec_script.size() == 70);
-                    bool is_simple_format = (exec_script.size() == 34);
-                    
-                    if (is_combined_format) {
-                        LogPrintf("SLH-DSA DEBUG: Combined script format detected (70 bytes), checking stack contents\n");
-                        LogPrintf("SLH-DSA DEBUG: Stack size: %zu\n", stack.size());
-                        for (size_t i = 0; i < stack.size(); i++) {
-                            LogPrintf("SLH-DSA DEBUG: Stack[%zu] size: %zu\n", i, stack[i].size());
-                        }
-                        
-                        // Add execution flow debugging
-                        LogPrintf("SLH-DSA DEBUG: ===== EXECUTION FLOW ANALYSIS =====\n");
-                        LogPrintf("SLH-DSA DEBUG: Script execution reached OP_SUBSTR\n");
-                        LogPrintf("SLH-DSA DEBUG: Previous opcodes executed:\n");
-                        LogPrintf("SLH-DSA DEBUG: - OP_PUSHBYTES_32 (Schnorr pubkey)\n");
-                        LogPrintf("SLH-DSA DEBUG: - OP_CHECKSIG (Schnorr verification)\n");
-                        LogPrintf("SLH-DSA DEBUG: - OP_PUSHBYTES_32 (SLH-DSA pubkey)\n");
-                        LogPrintf("SLH-DSA DEBUG: - OP_SUBSTR (SLH-DSA verification)\n");
-                        LogPrintf("SLH-DSA DEBUG: ===== END EXECUTION FLOW ANALYSIS =====\n");
-                        
-                        // For combined format, we need to handle the case where OP_CHECKSIG hasn't been executed yet
-                        // The stack might be: [schnorr_sig, slh_dsa_sig] or [slh_dsa_pubkey, schnorr_result, slh_dsa_sig]
-                        // Or the new combined format: [combined_sig(7922 bytes)]
-                        if (stack.size() == 1 && stack[0].size() == 7922) {
-                            LogPrintf("SLH-DSA DEBUG: Detected combined witness element (7922 bytes), proceeding with SLH-DSA verification\n");
-                            found_op_success127 = true;
-                            const auto* tx_checker = dynamic_cast<const GenericTransactionSignatureChecker<CTransaction>*>(&checker);
-                            if (!tx_checker) {
-                                LogPrintf("SLH-DSA DEBUG: Failed to cast checker to transaction checker\n");
-                                return set_error(serror, SCRIPT_ERR_SLHDSA_SIG);
-                            }
-                            return HandleSLHDSASignature(stack, exec_script, flags, *tx_checker, execdata, serror);
-                        } else if (stack.size() == 2 && stack[0].size() == 64 && stack[1].size() == 7856) {
-                            LogPrintf("SLH-DSA DEBUG: Detected pre-OP_CHECKSIG state, Schnorr sig and SLH-DSA sig present\n");
-                            LogPrintf("SLH-DSA DEBUG: This suggests OP_CHECKSIG failed or wasn't executed properly\n");
-                            LogPrintf("SLH-DSA DEBUG: Proceeding with SLH-DSA verification anyway for debugging\n");
-                            found_op_success127 = true;
-                            const auto* tx_checker = dynamic_cast<const GenericTransactionSignatureChecker<CTransaction>*>(&checker);
-                            if (!tx_checker) {
-                                LogPrintf("SLH-DSA DEBUG: Failed to cast checker to transaction checker\n");
-                                return set_error(serror, SCRIPT_ERR_SLHDSA_SIG);
-                            }
-                            return HandleSLHDSASignature(stack, exec_script, flags, *tx_checker, execdata, serror);
-                        } else if (stack.size() >= 3 && stack[1].size() == 1 && stack[1][0] == 1 && stack[2].size() >= 7856) {
-                            LogPrintf("SLH-DSA DEBUG: Schnorr verification succeeded and SLH-DSA signature found, proceeding\n");
-                            found_op_success127 = true;
-                            const auto* tx_checker = dynamic_cast<const GenericTransactionSignatureChecker<CTransaction>*>(&checker);
-                            if (!tx_checker) {
-                                LogPrintf("SLH-DSA DEBUG: Failed to cast checker to transaction checker\n");
-                                return set_error(serror, SCRIPT_ERR_SLHDSA_SIG);
-                            }
-                            return HandleSLHDSASignature(stack, exec_script, flags, *tx_checker, execdata, serror);
-                        } else {
-                            LogPrintf("SLH-DSA DEBUG: Invalid stack state - Schnorr result: %s, SLH-DSA sig size: %zu\n", 
-                                      stack.size() >= 2 ? (stack[1].size() == 1 && stack[1][0] == 1 ? "success" : "failed") : "missing",
-                                      stack.size() >= 3 ? stack[2].size() : 0);
-                            return set_error(serror, SCRIPT_ERR_SLHDSA_SIG);
-                        }
-                    } else if (is_simple_format) {
-                        // Simple format: check for large signature (7856+ bytes)
-                        if (stack.size() >= 1 && stack[0].size() >= 7856) {
-                            LogPrintf("SLH-DSA DEBUG: Large signature detected (%zu bytes), calling HandleSLHDSASignature\n", stack[0].size());
-                            found_op_success127 = true;
-                            const auto* tx_checker = dynamic_cast<const GenericTransactionSignatureChecker<CTransaction>*>(&checker);
-                            if (!tx_checker) {
-                                LogPrintf("SLH-DSA DEBUG: Failed to cast checker to transaction checker\n");
-                                return set_error(serror, SCRIPT_ERR_SLHDSA_SIG);
-                            }
-                            return HandleSLHDSASignature(stack, exec_script, flags, *tx_checker, execdata, serror);
-                        } else {
-                            LogPrintf("SLH-DSA DEBUG: OP_SUBSTR found but signature size %zu < 7856, treating as normal OP_SUCCESS\n", 
-                                      stack.size() > 0 ? stack[0].size() : 0);
-                            // Check if we should discourage OP_SUCCESS (for mempool policy)
-                            if (flags & SCRIPT_VERIFY_DISCOURAGE_OP_SUCCESS) {
-                                return set_error(serror, SCRIPT_ERR_DISCOURAGE_OP_SUCCESS);
-                            }
-                            // Treat as normal OP_SUCCESS (return success without SLH-DSA verification)
-                            return set_success(serror);
-                        }
-                    } else {
-                        LogPrintf("SLH-DSA DEBUG: Unknown script format (size %zu), treating as normal OP_SUCCESS\n", exec_script.size());
-                        // Check if we should discourage OP_SUCCESS (for mempool policy)
-                        if (flags & SCRIPT_VERIFY_DISCOURAGE_OP_SUCCESS) {
-                            return set_error(serror, SCRIPT_ERR_DISCOURAGE_OP_SUCCESS);
-                        }
-                        // Treat as normal OP_SUCCESS (return success without SLH-DSA verification)
-                        return set_success(serror);
-                    }
-                }
-                
-                // For all other OP_SUCCESSx opcodes, apply the standard discourage check
                 if (flags & SCRIPT_VERIFY_DISCOURAGE_OP_SUCCESS) {
                     return set_error(serror, SCRIPT_ERR_DISCOURAGE_OP_SUCCESS);
                 }
-                
                 return set_success(serror);
             }
         }
 
         // Tapscript enforces initial stack size limits (altstack is empty here)
         if (stack.size() > MAX_STACK_SIZE) return set_error(serror, SCRIPT_ERR_STACK_SIZE);
-        
-        // For SLH-DSA, allow larger stack elements if OP_SUCCESS127 was found
-        unsigned int max_element_size = found_op_success127 ? MAX_SCRIPT_ELEMENT_SIZE_SLHDSA : MAX_SCRIPT_ELEMENT_SIZE;
-        
-        // Disallow stack item size > max_element_size in witness stack
+
+        // Disallow stack item size > MAX_SCRIPT_ELEMENT_SIZE in witness stack
         for (const auto& elem : stack) {
-            if (elem.size() > max_element_size) {
-                LogPrintf("SLH-DSA DEBUG: Stack element size %zu exceeds limit %u (found_op_success127=%d)\n", 
-                         elem.size(), max_element_size, found_op_success127);
-                return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
-            }
+            if (elem.size() > MAX_SCRIPT_ELEMENT_SIZE) return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
         }
     } else {
         // Disallow stack item size > MAX_SCRIPT_ELEMENT_SIZE in witness stack
@@ -2401,15 +2027,16 @@ static bool VerifyWitnessProgram(const CScriptWitness& witness, int witversion,
             if (control_size < P2MR_CONTROL_BASE_SIZE || control_size > P2MR_CONTROL_MAX_SIZE || ((control_size - P2MR_CONTROL_BASE_SIZE) % TAPROOT_CONTROL_NODE_SIZE) != 0) {
                 return set_error(serror, SCRIPT_ERR_P2MR_WRONG_CONTROL_SIZE);
             }
+            if ((control[0] & 1) == 0) {
+                return set_error(serror, SCRIPT_ERR_P2MR_WRONG_PARITY_BIT);
+            }
             execdata.m_tapleaf_hash = ComputeTapleafHash(control[0] & TAPROOT_LEAF_MASK, script);
             if (!VerifyScriptInTshMerkleRootPath(control, program, CScript(script.begin(), script.end()))) {
                 return set_error(serror, SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH);
             }
             execdata.m_tapleaf_hash_init = true;
-            // Check for P2MR-specific parity requirement (must be 0xc1 for Tapscript)
-            if ((control[0] & TAPROOT_LEAF_MASK) == TAPROOT_LEAF_TAPSCRIPT &&
-                control[0] != P2MR_LEAF_TAPSCRIPT) {
-                return set_error(serror, SCRIPT_ERR_P2MR_WRONG_PARITY_BIT);
+            if (control_size == P2MR_CONTROL_BASE_SIZE) {
+                return set_success(serror);
             }
             if (control[0] == P2MR_LEAF_TAPSCRIPT) {
                 // Tapscript (leaf version 0xc1 since parity is always 1)
diff --git a/src/script/interpreter.h b/src/script/interpreter.h
index 6f59f5c8f755..7d9bd302cb2e 100644
--- a/src/script/interpreter.h
+++ b/src/script/interpreter.h
@@ -240,7 +240,7 @@ static constexpr size_t TAPROOT_CONTROL_NODE_SIZE = 32;
 static constexpr size_t TAPROOT_CONTROL_MAX_NODE_COUNT = 128;
 static constexpr size_t TAPROOT_CONTROL_MAX_SIZE = TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * TAPROOT_CONTROL_MAX_NODE_COUNT;
 static constexpr size_t P2MR_CONTROL_BASE_SIZE = 1;  // no tweaked pubkey
-static constexpr size_t P2MR_CONTROL_MAX_SIZE = TAPROOT_CONTROL_MAX_SIZE + TAPROOT_CONTROL_NODE_SIZE * TAPROOT_CONTROL_MAX_NODE_COUNT;
+static constexpr size_t P2MR_CONTROL_MAX_SIZE = P2MR_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * TAPROOT_CONTROL_MAX_NODE_COUNT;
 
 extern const HashWriter HASHER_TAPSIGHASH; //!< Hasher with tag "TapSighash" pre-fed to it.
 extern const HashWriter HASHER_TAPLEAF;    //!< Hasher with tag "TapLeaf" pre-fed to it.
@@ -296,10 +296,6 @@ class GenericTransactionSignatureChecker : public BaseSignatureChecker
     unsigned int nIn;
     const CAmount amount;
     const PrecomputedTransactionData* txdata;
-    
-    // Friend function for SLH-DSA signature verification
-    template<typename U>
-    friend bool HandleSLHDSASignature(std::vector<std::vector<unsigned char>>& stack, const CScript& exec_script, unsigned int flags, const GenericTransactionSignatureChecker<U>& checker, ScriptExecutionData& execdata, ScriptError* serror);
 
 protected:
     virtual bool VerifyECDSASignature(const std::vector<unsigned char>& vchSig, const CPubKey& vchPubKey, const uint256& sighash) const;
diff --git a/src/script/script.h b/src/script/script.h
index f700de81d8ab..b556aae6060d 100644
--- a/src/script/script.h
+++ b/src/script/script.h
@@ -27,9 +27,6 @@
 // Maximum number of bytes pushable to the stack
 static const unsigned int MAX_SCRIPT_ELEMENT_SIZE = 520;
 
-// Add this line after the existing MAX_SCRIPT_ELEMENT_SIZE definition
-static const unsigned int MAX_SCRIPT_ELEMENT_SIZE_SLHDSA = 8000;
-
 // Maximum number of non-push operations per script
 static const int MAX_OPS_PER_SCRIPT = 201;
 
diff --git a/src/script/script_error.cpp b/src/script/script_error.cpp
index e722b62df9a0..afdddcfe5a11 100644
--- a/src/script/script_error.cpp
+++ b/src/script/script_error.cpp
@@ -124,7 +124,7 @@ std::string ScriptErrorString(const ScriptError serror)
         case SCRIPT_ERR_P2MR_WRONG_CONTROL_SIZE:
             return "Invalid P2MR control block size";
         case SCRIPT_ERR_P2MR_WRONG_PARITY_BIT:
-            return "P2MR leaf must use parity bit 1 (0xc1)";
+            return "P2MR control byte must use parity bit 1";
         case SCRIPT_ERR_UNKNOWN_ERROR:
         case SCRIPT_ERR_ERROR_COUNT:
         default: break;
diff --git a/src/test/data/script_tests.json b/src/test/data/script_tests.json
index d89ff623260a..547dcbf8f801 100644
--- a/src/test/data/script_tests.json
+++ b/src/test/data/script_tests.json
@@ -2694,8 +2694,8 @@
     "",
     "0x52 0x20 0x7e04991706edb31549f786fa7113bb857ceb26174f7d08e9efa91decf13324a0",
     "P2SH,WITNESS,TAPROOT,P2MR",
-    "EVAL_FALSE",
-    "P2MR: Simple negative OP_EQUAL test post-activation"
+    "OK",
+    "P2MR: Depth-zero OP_EQUAL succeeds without executing script"
 ],
 [
     [
@@ -2725,7 +2725,7 @@
 [
     [
         "aa",
-        "aa",
+        "ab",
         0.00000001
     ],
     "",
diff --git a/src/test/descriptor_tests.cpp b/src/test/descriptor_tests.cpp
index 558045d74382..2ea7121b8494 100644
--- a/src/test/descriptor_tests.cpp
+++ b/src/test/descriptor_tests.cpp
@@ -2,9 +2,12 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <addresstype.h>
+#include <key_io.h>
 #include <pubkey.h>
 #include <script/descriptor.h>
 #include <script/sign.h>
+#include <script/solver.h>
 #include <test/util/setup_common.h>
 #include <util/check.h>
 #include <util/strencodings.h>
@@ -15,6 +18,7 @@
 #include <optional>
 #include <regex>
 #include <string>
+#include <variant>
 #include <vector>
 
 using namespace util::hex_literals;
@@ -580,6 +584,22 @@ BOOST_AUTO_TEST_CASE(descriptor_test)
     Check("wpkh(L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1)", "wpkh(03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd)", "wpkh(03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd)", SIGNABLE, {{"00149a1c78a507689f6f54b847ad1cef1e614ee23f1e"}}, OutputType::BECH32, /*op_desc_id=*/uint256{"4a47b7f497721bf3fc48c69a5d22bc1f3617238649a8ba7cb96fbd92fec84a7e"});
     Check("sh(wpkh(L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1))", "sh(wpkh(03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd))", "sh(wpkh(03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd))", SIGNABLE, {{"a91484ab21b1b2fd065d4504ff693d832434b6108d7b87"}}, OutputType::P2SH_SEGWIT, /*op_desc_id=*/uint256{"a13112753066b5c59473a87c5771b1694a10531944a60e0ab2d7ad66ecb65bcd"});
     Check("tr(L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1)", "tr(a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd)", "tr(a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd)", SIGNABLE | XONLY_KEYS, {{"512077aab6e066f8a7419c5ab714c12c67d25007ed55a43cadcacb4d7a970a093f11"}}, OutputType::BECH32M, /*op_desc_id=*/uint256{"4290f3d017b270be53b91abc56d9d2f23a3ff361d5b1d39550ba011e6cae0da5"});
+    {
+        FlatSigningProvider provider, out;
+        std::string error;
+        auto descs{Parse("tmr(pk(03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd))", provider, error)};
+        BOOST_REQUIRE_MESSAGE(descs.size() == 1, error);
+        std::vector<CScript> scripts;
+        BOOST_REQUIRE(descs[0]->Expand(0, provider, scripts, out));
+        BOOST_REQUIRE_EQUAL(scripts.size(), 1U);
+        BOOST_CHECK_EQUAL(HexStr(scripts[0]).substr(0, 4), "5220");
+        std::vector<std::vector<unsigned char>> solutions;
+        BOOST_CHECK(Solver(scripts[0], solutions) == TxoutType::WITNESS_V2_P2MR);
+        CTxDestination destination;
+        BOOST_REQUIRE(ExtractDestination(scripts[0], destination));
+        BOOST_CHECK(std::get_if<WitnessV2P2MR>(&destination));
+        BOOST_CHECK_EQUAL(EncodeDestination(destination).substr(0, 4), "bc1z");
+    }
     CheckUnparsable("sh(wpkh(L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY2))", "sh(wpkh(03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5))", "wpkh(): Pubkey '03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5' is invalid"); // Invalid pubkey
     CheckUnparsable("pkh(deadbeef/1/2'/3/4']L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1)", "pkh(deadbeef/1/2h/3/4h]03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd)", "pkh(): Key origin start '[ character expected but not found, got 'd' instead"); // Missing start bracket in key origin
     CheckUnparsable("pkh([deadbeef]/1/2'/3/4']L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1)", "pkh([deadbeef]/1/2'/3/4']03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd)", "pkh(): Multiple ']' characters found for a single pubkey"); // Multiple end brackets in key origin
diff --git a/src/test/fuzz/script.cpp b/src/test/fuzz/script.cpp
index 5d07c9c6043a..be7ba4920e78 100644
--- a/src/test/fuzz/script.cpp
+++ b/src/test/fuzz/script.cpp
@@ -157,21 +157,12 @@ FUZZ_TARGET(script, .init = initialize_script)
         if (!std::get_if<PubKeyDestination>(&tx_destination_1)) {
             // Only try to round trip non-pubkey destinations since PubKeyDestination has no encoding
             Assert(dest.empty() != valid);
-            
-            // TODO: Temporary workaround: Skip round-trip test for P2MR during transition
-            if (!std::get_if<WitnessV2P2MR>(&tx_destination_1)) {
-                // Add debugging to see what type of destination is failing
-                if (std::get_if<WitnessUnknown>(&tx_destination_1)) {
-                    // Skip WitnessUnknown as well during transition
-                    // TODO: Remove this once all witness types are properly handled
-                } else {
-                    Assert(tx_destination_1 == DecodeDestination(encoded_dest));
-                }
+
+            if (!std::get_if<WitnessUnknown>(&tx_destination_1)) {
+                Assert(tx_destination_1 == DecodeDestination(encoded_dest));
             }
-            
-            // TODO: Temporary workaround: Skip validity check for problematic destination types
-            if (!std::get_if<WitnessV2P2MR>(&tx_destination_1) && 
-                !std::get_if<WitnessUnknown>(&tx_destination_1)) {
+
+            if (!std::get_if<WitnessUnknown>(&tx_destination_1)) {
                 Assert(valid == IsValidDestinationString(encoded_dest));
             }
         }
diff --git a/src/test/key_io_tests.cpp b/src/test/key_io_tests.cpp
index dbe7a29b7930..83f2efa0b101 100644
--- a/src/test/key_io_tests.cpp
+++ b/src/test/key_io_tests.cpp
@@ -5,6 +5,7 @@
 #include <test/data/key_io_invalid.json.h>
 #include <test/data/key_io_valid.json.h>
 
+#include <addresstype.h>
 #include <key.h>
 #include <key_io.h>
 #include <script/script.h>
@@ -17,9 +18,26 @@
 #include <boost/test/unit_test.hpp>
 
 #include <algorithm>
+#include <variant>
 
 BOOST_FIXTURE_TEST_SUITE(key_io_tests, BasicTestingSetup)
 
+BOOST_AUTO_TEST_CASE(key_io_p2mr_roundtrip)
+{
+    SelectParams(ChainType::MAIN);
+
+    uint256 root;
+    std::fill(root.begin(), root.end(), uint8_t{0x11});
+    const WitnessV2P2MR p2mr{root};
+    const std::string address{EncodeDestination(p2mr)};
+    BOOST_CHECK_EQUAL(address.substr(0, 4), "bc1z");
+
+    const CTxDestination decoded{DecodeDestination(address)};
+    BOOST_REQUIRE(IsValidDestination(decoded));
+    BOOST_CHECK(std::get<WitnessV2P2MR>(decoded) == p2mr);
+    BOOST_CHECK_EQUAL(HexStr(GetScriptForDestination(decoded)).substr(0, 4), "5220");
+}
+
 // Goal: check that parsed keys match test payload
 BOOST_AUTO_TEST_CASE(key_io_valid_parse)
 {
@@ -56,19 +74,8 @@ BOOST_AUTO_TEST_CASE(key_io_valid_parse)
             // Must be valid public key
             destination = DecodeDestination(exp_base58string);
             CScript script = GetScriptForDestination(destination);
-            
-            // Check if this is a witness version 2 address (P2MR or other v2 types)
-            bool is_p2mr = false;
-            if (exp_payload.size() >= 2 && static_cast<int>(exp_payload[0]) == 0x52) {
-                is_p2mr = true;
-            }
-            
-            if (is_p2mr) {
-                // TODO: Add P2MR-specific validation here
-            } else {
-                BOOST_CHECK_MESSAGE(IsValidDestination(destination), "!IsValid:" + strTest);
-                BOOST_CHECK_EQUAL(HexStr(script), HexStr(exp_payload));
-            }
+            BOOST_CHECK_MESSAGE(IsValidDestination(destination), "!IsValid:" + strTest);
+            BOOST_CHECK_EQUAL(HexStr(script), HexStr(exp_payload));
 
             // Try flipped case version
             for (char& c : exp_base58string) {
@@ -79,15 +86,10 @@ BOOST_AUTO_TEST_CASE(key_io_valid_parse)
                 }
             }
             destination = DecodeDestination(exp_base58string);
-            
-            if (is_p2mr) {
-                // TODO: Add P2MR-specific case flip validation here
-            } else {
-                BOOST_CHECK_MESSAGE(IsValidDestination(destination) == try_case_flip, "!IsValid case flipped:" + strTest);
-                if (IsValidDestination(destination)) {
-                    script = GetScriptForDestination(destination);
-                    BOOST_CHECK_EQUAL(HexStr(script), HexStr(exp_payload));
-                }
+            BOOST_CHECK_MESSAGE(IsValidDestination(destination) == try_case_flip, "!IsValid case flipped:" + strTest);
+            if (IsValidDestination(destination)) {
+                script = GetScriptForDestination(destination);
+                BOOST_CHECK_EQUAL(HexStr(script), HexStr(exp_payload));
             }
 
             // Public key must be invalid private key
diff --git a/src/test/script_assets_tests.cpp b/src/test/script_assets_tests.cpp
index 69e1e74641a6..5c5c59e2c721 100644
--- a/src/test/script_assets_tests.cpp
+++ b/src/test/script_assets_tests.cpp
@@ -128,7 +128,7 @@ static void AssetTest(const UniValue& test, SignatureCache& signature_cache)
                 // Check if this is a P2MR script (witness version 2, 32-byte program)
                 bool is_p2mr_script = false;
                 if (prevouts[idx].scriptPubKey.size() >= 2 && 
-                    prevouts[idx].scriptPubKey[0] == 0x53 && // witness version 2
+                    prevouts[idx].scriptPubKey[0] == 0x52 && // witness version 2
                     prevouts[idx].scriptPubKey[1] == 0x20 && // 32-byte program
                     tx.vin[idx].scriptSig.empty()) {  // P2MR should have empty ScriptSig
                     is_p2mr_script = true;
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
index 17ccb87912e9..22541a96b5e7 100644
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -11,6 +11,7 @@
 #include <rpc/util.h>
 #include <script/script.h>
 #include <script/script_error.h>
+#include <script/interpreter.h>
 #include <script/sigcache.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
@@ -423,6 +424,33 @@ std::string JSONPrettyPrint(const UniValue& univalue)
 
 BOOST_FIXTURE_TEST_SUITE(script_tests, ScriptTest)
 
+BOOST_AUTO_TEST_CASE(p2mr_control_size)
+{
+    CScriptWitness witness;
+    const CScript leaf_script{CScript() << OP_TRUE};
+    witness.stack.emplace_back(leaf_script.begin(), leaf_script.end());
+
+    std::vector<unsigned char> control(P2MR_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * (TAPROOT_CONTROL_MAX_NODE_COUNT + 1), 0);
+    control[0] = P2MR_LEAF_TAPSCRIPT;
+    witness.stack.push_back(control);
+
+    CScript script_pubkey;
+    script_pubkey << OP_2 << std::vector<unsigned char>(WITNESS_V2_P2MR_SIZE, 1);
+    DoTest(script_pubkey, CScript{}, witness, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_TAPROOT | SCRIPT_VERIFY_P2MR, "P2MR control block depth above 128", SCRIPT_ERR_P2MR_WRONG_CONTROL_SIZE);
+}
+
+BOOST_AUTO_TEST_CASE(p2mr_future_leaf_parity)
+{
+    CScriptWitness witness;
+    const CScript leaf_script{CScript() << OP_TRUE};
+    witness.stack.emplace_back(leaf_script.begin(), leaf_script.end());
+    witness.stack.push_back({0xc2});
+
+    CScript script_pubkey;
+    script_pubkey << OP_2 << ToByteVector(ComputeTapleafHash(0xc2, witness.stack[0]));
+    DoTest(script_pubkey, CScript{}, witness, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_TAPROOT | SCRIPT_VERIFY_P2MR, "P2MR future leaf version with parity bit zero", SCRIPT_ERR_P2MR_WRONG_PARITY_BIT);
+}
+
 BOOST_AUTO_TEST_CASE(script_build)
 {
     const KeyData keys;
diff --git a/src/test/transaction_tests.cpp b/src/test/transaction_tests.cpp
index b6d0b6375df3..098190a7b288 100644
--- a/src/test/transaction_tests.cpp
+++ b/src/test/transaction_tests.cpp
@@ -1055,6 +1055,35 @@ BOOST_AUTO_TEST_CASE(test_IsStandard)
     CheckIsNotStandard(t, "dust");
 }
 
+BOOST_AUTO_TEST_CASE(p2mr_witness_standard_stack_item_size)
+{
+    CCoinsView coins_dummy;
+    CCoinsViewCache coins(&coins_dummy);
+
+    CMutableTransaction funding;
+    funding.vin.resize(1);
+    funding.vin[0].prevout.SetNull();
+    funding.vout.emplace_back(
+        CENT,
+        CScript{} << OP_2 << std::vector<unsigned char>(WITNESS_V2_P2MR_SIZE, 1));
+    AddCoins(coins, CTransaction{funding}, 0, false);
+
+    const auto make_spend = [&](const size_t item_size) {
+        CMutableTransaction spend;
+        spend.vin.emplace_back(COutPoint{funding.GetHash(), 0});
+        spend.vout.emplace_back(CENT - 1, CScript{} << OP_TRUE);
+        spend.vin[0].scriptWitness.stack = {
+            std::vector<unsigned char>(item_size, 1),
+            std::vector<unsigned char>{OP_TRUE},
+            std::vector<unsigned char>{P2MR_LEAF_TAPSCRIPT},
+        };
+        return CTransaction{spend};
+    };
+
+    BOOST_CHECK(IsWitnessStandard(make_spend(MAX_STANDARD_P2MR_STACK_ITEM_SIZE), coins));
+    BOOST_CHECK(!IsWitnessStandard(make_spend(MAX_STANDARD_P2MR_STACK_ITEM_SIZE + 1), coins));
+}
+
 BOOST_AUTO_TEST_CASE(max_standard_legacy_sigops)
 {
     CCoinsView coins_dummy;
diff --git a/src/validation.cpp b/src/validation.cpp
index 90e70834bcbb..a81410dd34d6 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -2360,9 +2360,9 @@ static unsigned int GetBlockScriptFlags(const CBlockIndex& block_index, const Ch
     // mainnet and testnet).
     // Similarly, only one historical block violated the TAPROOT rules on
     // mainnet.
-    // For simplicity, always leave P2SH+WITNESS+TAPROOT on except for the two
+    // For simplicity, always leave P2SH+WITNESS+TAPROOT+P2MR on except for the two
     // violating blocks.
-    uint32_t flags{SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_TAPROOT};
+    uint32_t flags{SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_TAPROOT | SCRIPT_VERIFY_P2MR};
     const auto it{consensusparams.script_flag_exceptions.find(*Assert(block_index.phashBlock))};
     if (it != consensusparams.script_flag_exceptions.end()) {
         flags = it->second;
diff --git a/test/functional/feature_p2mr.py b/test/functional/feature_p2mr.py
new file mode 100644
index 000000000000..0924c104140c
--- /dev/null
+++ b/test/functional/feature_p2mr.py
@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test Pay-to-Merkle-Root consensus behavior."""
+
+from test_framework.blocktools import (
+    COINBASE_MATURITY,
+    add_witness_commitment,
+    create_block,
+    create_coinbase,
+)
+from test_framework.key import TaggedHash
+from test_framework.messages import (
+    COutPoint,
+    CTransaction,
+    CTxIn,
+    CTxInWitness,
+    CTxOut,
+    COIN,
+    SEQUENCE_FINAL,
+    ser_string,
+)
+from test_framework.script import (
+    CScript,
+    LEAF_VERSION_TAPSCRIPT,
+    OP_2,
+    OP_TRUE,
+)
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal
+
+
+class P2MRTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.setup_clean_chain = True
+        self.extra_args = [["-acceptnonstdtxn=1"]]
+
+    def _mine_block(self, txs=None, *, script_pubkey=None):
+        node = self.nodes[0]
+        height = node.getblockcount() + 1
+        block = create_block(
+            hashprev=int(node.getbestblockhash(), 16),
+            coinbase=create_coinbase(height, script_pubkey=script_pubkey),
+            ntime=self._next_block_time(),
+            txlist=txs or [],
+        )
+        if txs:
+            add_witness_commitment(block)
+        block.solve()
+        assert_equal(node.submitblock(block.serialize().hex()), None)
+        return block
+
+    def _next_block_time(self):
+        return self.nodes[0].getblockheader(self.nodes[0].getbestblockhash())["mediantime"] + 1
+
+    def _p2mr_root(self, leaf_script):
+        return TaggedHash("TapLeaf", bytes([LEAF_VERSION_TAPSCRIPT]) + ser_string(bytes(leaf_script)))
+
+    def _spend_tx(self, funding_tx, witness_stack):
+        spend = CTransaction()
+        spend.vin.append(CTxIn(COutPoint(funding_tx.txid_int, 0), b"", SEQUENCE_FINAL))
+        spend.vout.append(CTxOut(49 * COIN, CScript([OP_TRUE])))
+        spend.vout.append(CTxOut(COIN - 10_000, CScript([OP_TRUE])))
+        spend.wit.vtxinwit = [CTxInWitness()]
+        spend.wit.vtxinwit[0].scriptWitness.stack = witness_stack
+        return spend
+
+    def run_test(self):
+        node = self.nodes[0]
+
+        self.log.info("Mine native v2 32-byte outputs")
+        leaf_script = CScript([OP_TRUE])
+        valid_p2mr_script = CScript([OP_2, self._p2mr_root(leaf_script)])
+        valid_funding_block = self._mine_block(script_pubkey=valid_p2mr_script)
+        valid_funding_tx = valid_funding_block.vtx[0]
+
+        invalid_p2mr_script = CScript([OP_2, b"\x11" * 32])
+        invalid_funding_block = self._mine_block(script_pubkey=invalid_p2mr_script)
+        invalid_funding_tx = invalid_funding_block.vtx[0]
+
+        self.generate(node, COINBASE_MATURITY)
+
+        self.log.info("Accept and mine a valid depth-zero P2MR spend")
+        valid_spend = self._spend_tx(valid_funding_tx, [bytes(leaf_script), b"\xc1"])
+        mempool_accept = node.testmempoolaccept([valid_spend.serialize().hex()])[0]
+        assert mempool_accept["allowed"], mempool_accept
+        valid_txid = node.sendrawtransaction(valid_spend.serialize().hex())
+        block_hash = self.generate(node, 1)[0]
+        assert valid_txid in [tx["txid"] for tx in node.getblock(block_hash, 2)["tx"]]
+
+        self.log.info("Reject a block that spends P2MR through the unknown-witness path")
+        spend = self._spend_tx(invalid_funding_tx, [b"not a p2mr script path"])
+
+        height = node.getblockcount() + 1
+        bad_block = create_block(
+            hashprev=int(node.getbestblockhash(), 16),
+            coinbase=create_coinbase(height),
+            ntime=self._next_block_time(),
+            txlist=[spend],
+        )
+        add_witness_commitment(bad_block)
+        bad_block.solve()
+        assert_equal(node.submitblock(bad_block.serialize().hex()), "mandatory-script-verify-flag-failed (Witness program hash mismatch)")
+
+
+if __name__ == "__main__":
+    P2MRTest(__file__).main()
diff --git a/test/functional/feature_taproot.py b/test/functional/feature_taproot.py
index 94c943b28db4..4acf36671361 100755
--- a/test/functional/feature_taproot.py
+++ b/test/functional/feature_taproot.py
@@ -3,11 +3,6 @@
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 # Test Taproot softfork (BIPs 340-342)
-#
-# NOTE: This test file has been modified for SLH-DSA development.
-# Only OP_SUBSTR (127) tests are disabled because they conflict with the SLH-DSA 
-# implementation that uses OP_SUBSTR (127) for signature verification.
-# All other OP_SUCCESSx tests have been re-enabled and work normally.
 
 from test_framework.blocktools import (
     COINBASE_MATURITY,
@@ -839,6 +834,8 @@ def mutate(spk):
                 if not p2sh and witver == 1 and witlen == 32:
                     add_spender(spenders, "applic/keypath", p2sh=p2sh, spk_mutate_pre_p2sh=mutate, tap=tap, key=secs[1], **SIGHASH_BITFLIP, **ERR_SCHNORR_SIG)
                     add_spender(spenders, "applic/scriptpath", p2sh=p2sh, leaf="s0", spk_mutate_pre_p2sh=mutate, tap=tap, key=secs[0], **SINGLE_SIG, failure={"leaf": "dummy"}, **ERR_OP_RETURN)
+                elif not p2sh and witver == 2 and witlen == 32:
+                    continue
                 else:
                     add_spender(spenders, "applic/keypath", p2sh=p2sh, spk_mutate_pre_p2sh=mutate, tap=tap, key=secs[1], standard=False)
                     add_spender(spenders, "applic/scriptpath", p2sh=p2sh, leaf="s0", spk_mutate_pre_p2sh=mutate, tap=tap, key=secs[0], **SINGLE_SIG, standard=False)
@@ -1152,12 +1149,6 @@ def predict_sigops_ratio(n, dummy_size):
         opcode = CScriptOp(opval)
         if not is_op_success(opcode):
             continue
-        
-        # SKIP OP_SUBSTR (127) TESTS FOR SLH-DSA DEVELOPMENT
-        # OP_SUBSTR is used for SLH-DSA signature verification and behaves differently
-        # than other OP_SUCCESSx opcodes, breaking the test expectations.
-        if opcode == 127:  # OP_SUBSTR
-            continue
         scripts = [
             ("bare_success", CScript([opcode])),
             ("bare_nop", CScript([OP_NOP])),
diff --git a/test/functional/rpc_p2qrh.py b/test/functional/rpc_p2qrh.py
deleted file mode 100755
index 880173669153..000000000000
--- a/test/functional/rpc_p2qrh.py
+++ /dev/null
@@ -1,226 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2017-2022 The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Test the RPC call related to the uptime command.
-
-Test corresponds to code in rpc/server.cpp.
-"""
-
-import time
-import json
-
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_raises_rpc_error
-
-
-class TestP2Qrh(BitcoinTestFramework):
-    WALLET_NAME = "regtest"
-    WALLET_PASSPHRASE = "regtest"
-    TOTAL_LEAF_COUNT = 5
-    LEAF_OF_INTEREST = 4
-    BITCOIN_ADDRESS_INFO = '{ "taptree_return": { "leaf_script_priv_key_hex": "cd99b36815af6c7c70fe3e029800714599f0be1725b7d6a88c8b653cac694007", "leaf_script_hex": "202104496c8c514c38a2e31e36d2acb2d43d9a3e7cf5da5fe1d2b0a770f6c3c10bac", "tree_root_hex": "1e5445529fda20fd2ecea2322fdf9ae07adaaad859b9f9856b631bccc46cf0be", "control_block_hex": "c1fa37ef0058db467387b796e16e2c6e082068a70370ba027e15419a310d5ae3678d24f91c62d8cdfe0c5193f0c33d2e5e71d9cec577b0b48f7fb622af8b7dbc8d761051217d788a00b625036265ba3ef60d0644df00fb37da4516c4ac7c4c5abb" }, "utxo_return": { "script_pubkey_hex": "53201e5445529fda20fd2ecea2322fdf9ae07adaaad859b9f9856b631bccc46cf0be", "bech32m_address": "bcrt1rre2y255lmgs06tkw5gezlhu6upad42kctxulnpttvvdue3rv7zlqqukutx", "bitcoin_network": "regtest" } }'
-    FUNDING_UTXO_INDEX = 0
-    BLOCK_COUNT_AFTER_COINBASE_FUNDING = 110
-    SPEND_DETAILS = '{ "tx_hex": "02000000000101e8076c387194ec46bbd234c812b12fa3313e645ed2f143a7db6a899ecb246cbc0000000000ffffffff0178de052a010000001600140de745dc58d8e62e6f47bde30cd5804a82016f9e03412e2ebc83bf39ff9b31c94ff165b1f731950d25d221f5571102b95c01f4b8e2670894e6b6f1a2a2a285f690ce496d70fd7b818a32576a7c51ae0c9e2edad2b7a00122202104496c8c514c38a2e31e36d2acb2d43d9a3e7cf5da5fe1d2b0a770f6c3c10bac61c1fa37ef0058db467387b796e16e2c6e082068a70370ba027e15419a310d5ae3678d24f91c62d8cdfe0c5193f0c33d2e5e71d9cec577b0b48f7fb622af8b7dbc8d761051217d788a00b625036265ba3ef60d0644df00fb37da4516c4ac7c4c5abb00000000", "sighash": "14ddf2df5f790fc2fbb8c3db54d903730e191518b7b3bb279f6d0ce1df64c7e8", "sig_bytes": "2e2ebc83bf39ff9b31c94ff165b1f731950d25d221f5571102b95c01f4b8e2670894e6b6f1a2a2a285f690ce496d70fd7b818a32576a7c51ae0c9e2edad2b7a001", "derived_witness_vec": "2e2ebc83bf39ff9b31c94ff165b1f731950d25d221f5571102b95c01f4b8e2670894e6b6f1a2a2a285f690ce496d70fd7b818a32576a7c51ae0c9e2edad2b7a001202104496c8c514c38a2e31e36d2acb2d43d9a3e7cf5da5fe1d2b0a770f6c3c10bacc1fa37ef0058db467387b796e16e2c6e082068a70370ba027e15419a310d5ae3678d24f91c62d8cdfe0c5193f0c33d2e5e71d9cec577b0b48f7fb622af8b7dbc8d761051217d788a00b625036265ba3ef60d0644df00fb37da4516c4ac7c4c5abb" }'
-
-    def set_test_params(self):
-        self.num_nodes = 1
-        self.setup_clean_chain = True
-        self.uses_wallet = True  # Enable wallet functionality
-        # Enable txindex so getrawtransaction can find transactions in the blockchain
-        self.extra_args = [["-txindex"]]
-
-    def skip_test_if_missing_module(self):
-        self.skip_if_no_wallet()
-
-    def run_test(self):
-        # self._list_available_methods()
-        self._create_wallet()
-        self._parse_bitcoin_address_info()
-        self._fund_p2qrh_address()
-        self._first_p2qrh_tx()
-        self._get_funding_utxo_details()
-        self._generate_post_coinbase_blocks()
-        self._set_spend_detail_variables()
-        self._test_mempool_accept()
-        self._submit_tx_and_mine()
-        self._view_blockhash_info()
-    
-    def _list_available_methods(self):
-        """List available RPC methods to debug the issue"""
-        node = self.nodes[0]
-        
-        # Get all available commands
-        all_help = node.help()
-        self.log.info("All available RPC commands:")
-        self.log.info(all_help)
-        
-        # Check if wallet-related commands are available
-        wallet_commands = [cmd for cmd in all_help.split('\n') if 'wallet' in cmd.lower()]
-        self.log.info(f"Wallet-related commands: {wallet_commands}")
-    
-    def _create_wallet(self):
-        try:
-            # Capture the response from createwallet
-            response = self.nodes[0].createwallet(wallet_name=self.WALLET_NAME, descriptors=True, passphrase=self.WALLET_PASSPHRASE, load_on_startup=True)
-            
-            # Log the response
-            self.log.info(f"createwallet response: {response}")
-        except Exception as e:
-            self.log.error(f"Error creating wallet: {e}")
-            # Try alternative wallet creation method
-            try:
-                response = self.nodes[0].createwallet(self.WALLET_NAME)
-                self.log.info(f"Alternative createwallet response: {response}")
-            except Exception as e2:
-                self.log.error(f"Alternative method also failed: {e2}")
-
-    def _parse_bitcoin_address_info(self):
-        try:
-            # Parse the JSON response
-            data = json.loads(self.BITCOIN_ADDRESS_INFO)
-            
-            # Extract the relevant information
-            taptree_return = data.get('taptree_return', {})
-            utxo_return = data.get('utxo_return', {})
-            
-            # Extract individual fields (equivalent to your bash exports)
-            self.quantum_root = taptree_return.get('tree_root_hex')
-            self.leaf_script_priv_key_hex = taptree_return.get('leaf_script_priv_key_hex')
-            self.leaf_script_hex = taptree_return.get('leaf_script_hex')
-            self.control_block_hex = taptree_return.get('control_block_hex')
-            self.funding_script_pubkey = utxo_return.get('script_pubkey_hex')
-            self.p2qrh_addr = utxo_return.get('bech32m_address')
-            
-            # Log the extracted values for debugging
-            self.log.info(f"quantum_root: {self.quantum_root}")
-            self.log.info(f"leaf_script_priv_key_hex: {self.leaf_script_priv_key_hex}")
-            self.log.info(f"leaf_script_hex: {self.leaf_script_hex}")
-            self.log.info(f"control_block_hex: {self.control_block_hex}")
-            self.log.info(f"funding_script_pubkey: {self.funding_script_pubkey}")
-            self.log.info(f"p2qrh_addr: {self.p2qrh_addr}")
-            
-            # Verify all required fields were extracted
-            required_fields = [
-                self.quantum_root,
-                self.leaf_script_priv_key_hex,
-                self.leaf_script_hex,
-                self.control_block_hex,
-                self.funding_script_pubkey,
-                self.p2qrh_addr
-            ]
-            
-            if all(required_fields):
-                self.log.info("All required fields successfully extracted")
-            else:
-                missing_fields = []
-                if not self.quantum_root: missing_fields.append("tree_root_hex")
-                if not self.leaf_script_priv_key_hex: missing_fields.append("leaf_script_priv_key_hex")
-                if not self.leaf_script_hex: missing_fields.append("leaf_script_hex")
-                if not self.control_block_hex: missing_fields.append("control_block_hex")
-                if not self.funding_script_pubkey: missing_fields.append("script_pubkey_hex")
-                if not self.p2qrh_addr: missing_fields.append("bech32m_address")
-                
-                self.log.error(f"Missing required fields: {missing_fields}")
-                
-        except json.JSONDecodeError as e:
-            self.log.error(f"Failed to parse JSON: {e}")
-        except Exception as e:
-            self.log.error(f"Error parsing bitcoin address info: {e}")
-
-    def _fund_p2qrh_address(self):
-        try:
-            # Fund the p2qrh address
-            response = self.generatetoaddress(self.nodes[0], nblocks=1, address=self.p2qrh_addr, maxtries=10)
-            self.log.info(f"Funding p2qrh address: {response}")
-        except Exception as e:
-            self.log.error(f"Error funding p2qrh address: {e}")
-
-    def _first_p2qrh_tx(self):
-        try:
-            self.p2qrh_descriptor_info = self.nodes[0].getdescriptorinfo(descriptor=f"addr({self.p2qrh_addr})")
-            self.log.info(f"P2QRH descriptor info: {self.p2qrh_descriptor_info}")
-            desc = self.p2qrh_descriptor_info['descriptor']
-            scan_objects = [{"desc": desc}]
-            response = self.nodes[0].scantxoutset(action="start", scanobjects=scan_objects)
-            self.log.info(f"scantxoutset response: {response}")
-            
-            # Extract the funding transaction ID from the first unspent
-            if response.get('unspents') and len(response['unspents']) > 0:
-                self.funding_tx_id = response['unspents'][0]['txid']
-                self.log.info(f"Funding transaction ID: {self.funding_tx_id}")
-            else:
-                self.log.error("No unspent outputs found in scantxoutset response")
-        except Exception as e:
-            self.log.error(f"Error getting txs for p2qrh address: {e}")
-
-    def _get_funding_utxo_details(self):
-        try:
-            response = self.nodes[0].getrawtransaction(txid=self.funding_tx_id, verbosity=1)
-            
-            self.log.info(f"Funding utxo details: {response}")
-            
-            # Extract the value from the specific UTXO index and convert to satoshis
-            if 'vout' in response and len(response['vout']) > self.FUNDING_UTXO_INDEX:
-                utxo = response['vout'][self.FUNDING_UTXO_INDEX]
-                if 'value' in utxo:
-                    # Convert BTC value to satoshis (multiply by 100,000,000)
-                    btc_value = float(utxo['value'])
-                    self.funding_utxo_amount_sats = int(btc_value * 100000000)
-                    self.log.info(f"Funding UTXO amount in satoshis: {self.funding_utxo_amount_sats}")
-                else:
-                    self.log.error("No 'value' field found in UTXO")
-            else:
-                self.log.error(f"UTXO index {self.FUNDING_UTXO_INDEX} not found in transaction outputs")
-                
-        except Exception as e:
-            self.log.error(f"Error getting funding utxo details: {e}")
-
-    def _generate_post_coinbase_blocks(self):
-        try:
-            response = self.generate(self.nodes[0], nblocks=self.BLOCK_COUNT_AFTER_COINBASE_FUNDING)
-            self.log.info(f"Generating post-coinbase blocks: {response}")
-            
-            # Count the block IDs in the response
-            block_count = len(response)
-            self.log.info(f"Generated {block_count} blocks")
-            
-        except Exception as e:
-            self.log.error(f"Error generating post-coinbase blocks: {e}")
-
-    def _set_spend_detail_variables(self):
-        try:
-            data = json.loads(self.SPEND_DETAILS)
-            self.tx_hex = data.get('tx_hex')
-            self.sighash = data.get('sighash')
-            self.sig_bytes = data.get('sig_bytes')
-            self.derived_witness_vec = data.get('derived_witness_vec')
-        except Exception as e:
-            self.log.error(f"Error setting spend detail variables: {e}")
-
-    def _test_mempool_accept(self):
-        try:
-            response = self.nodes[0].testmempoolaccept(rawtxs=[self.tx_hex])
-            self.log.info(f"testmempoolaccept response: {response}")
-        except Exception as e:
-            self.log.error(f"Error testing testmempoolaccept: {e}")
-    
-    def _submit_tx_and_mine(self):
-        try:
-            self.p2qrh_spending_tx_id = self.nodes[0].sendrawtransaction(self.tx_hex)
-            self.log.info(f"sendrawtransaction response: {self.p2qrh_spending_tx_id}")
-            self.generate(self.nodes[0], nblocks=1)
-        except Exception as e:
-            self.log.error(f"Error submitting tx: {e}")
-
-    def _view_blockhash_info(self):
-        try:
-            response = self.nodes[0].getrawtransaction(txid=self.p2qrh_spending_tx_id, verbosity=1)
-            self.block_hash = response['blockhash']
-            self.log.info(f"blockhash containing p2qrh spend tx: {self.block_hash}")
-        except Exception as e:
-            self.log.error(f"Error getting blockhash: {e}")
-
-if __name__ == '__main__':
-    TestP2Qrh(__file__).main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index a32e661bb300..4a9a2f6faf13 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -105,8 +105,8 @@
     'feature_assumeutxo.py',
     'mempool_updatefromblock.py',
     'mempool_persist.py',
+    'feature_p2mr.py',
     # vv Tests less than 60s vv
-    'rpc_p2qrh.py',
     'rpc_psbt.py',
     'wallet_fundrawtransaction.py',
     'wallet_bumpfee.py',