diff --git a/cardano_node_tests/tests/test_addr_registration.py b/cardano_node_tests/tests/test_addr_registration.py
index 7a48bf7ca..07ef67ff8 100644
--- a/cardano_node_tests/tests/test_addr_registration.py
+++ b/cardano_node_tests/tests/test_addr_registration.py
@@ -789,3 +789,57 @@ def _submit_tx(
         else:
             err = f"Invalid issue: {issue}"
             raise ValueError(err)
+
+    @allure.link(helpers.get_vcs_link())
+    @pytest.mark.parametrize("era", ("shelley", "allegra", "mary", "alonzo", "babbage"))
+    @pytest.mark.testnets
+    @pytest.mark.smoke
+    def test_legacy_stake_addr_registration_rejected_in_conway(
+        self,
+        cluster_manager: cluster_management.ClusterManager,
+        cluster: clusterlib.ClusterLib,
+        era: str,
+    ):
+        """Reject legacy stake address registration in Conway.
+
+        * Generate a stake address registration certificate using the compatible CLI
+        for a legacy era.
+        * Attempt to submit the legacy certificate in a Conway-era transaction.
+        * Expect the transaction submission to fail with a TextEnvelope type error.
+        """
+        temp_template = common.get_test_id(cluster)
+
+        pool_users = common.get_pool_users(
+            name_template=f"{temp_template}_{era}_legacy",
+            cluster_manager=cluster_manager,
+            cluster_obj=cluster,
+            num=1,
+            fund_idx=[0],
+            amount=600_000_000,
+        )
+
+        era_api = getattr(cluster.g_compatible, era)
+
+        legacy_stake_reg_cert = era_api.stake_address.gen_registration_cert(
+            name=f"{temp_template}_{era}_stake",
+            stake_vkey_file=pool_users[0].stake.vkey_file,
+        )
+
+        tx_files = clusterlib.TxFiles(
+            certificate_files=[legacy_stake_reg_cert],
+            signing_key_files=[
+                pool_users[0].payment.skey_file,
+                pool_users[0].stake.skey_file,
+            ],
+        )
+
+        with pytest.raises(clusterlib.CLIError) as excinfo:
+            cluster.g_transaction.send_tx(
+                src_address=pool_users[0].payment.address,
+                tx_name=f"{temp_template}_{era}_legacy_stake_reg",
+                tx_files=tx_files,
+            )
+
+        err = str(excinfo.value)
+
+        assert "TextEnvelope type error" in err, err
diff --git a/cardano_node_tests/tests/test_delegation.py b/cardano_node_tests/tests/test_delegation.py
index f4cc27aed..eb8e6bf89 100644
--- a/cardano_node_tests/tests/test_delegation.py
+++ b/cardano_node_tests/tests/test_delegation.py
@@ -1249,3 +1249,73 @@ def test_delegatee_not_registered(
             "DelegateeNotRegisteredDELEG" in err_msg  # Before cardano-node 10.0.0
             or "DelegateeStakePoolNotRegisteredDELEG" in err_msg
         ), err_msg
+
+    @allure.link(helpers.get_vcs_link())
+    @pytest.mark.parametrize("era", ("shelley", "allegra", "mary", "alonzo", "babbage"))
+    @pytest.mark.testnets
+    @pytest.mark.smoke
+    def test_legacy_stake_delegation_rejected_in_conway(
+        self,
+        cluster_manager: cluster_management.ClusterManager,
+        cluster: clusterlib.ClusterLib,
+        era: str,
+    ):
+        """Reject legacy stake address delegation in Conway.
+
+        * Register stake address using Conway-era commands.
+        * Generate a stake address delegation certificate using the compatible CLI
+          for a legacy era.
+        * Attempt to submit the legacy certificate in a Conway-era transaction.
+        * Expect the transaction submission to fail with a TextEnvelope type error.
+        """
+        temp_template = common.get_test_id(cluster)
+
+        # Create funded pool user
+        pool_users = common.get_pool_users(
+            name_template=f"{temp_template}_{era}_legacy",
+            cluster_manager=cluster_manager,
+            cluster_obj=cluster,
+            num=1,
+            fund_idx=[0],
+            amount=600_000_000,
+        )
+        pool_user = pool_users[0]
+
+        # Register stake address using Conway commands
+        clusterlib_utils.register_stake_address(
+            cluster_obj=cluster,
+            pool_user=pool_user,
+            name_template=f"{temp_template}_{era}_reg",
+            deposit_amt=cluster.g_query.get_address_deposit(),
+        )
+
+        # Use an EXISTING registered pool
+        pool_ids = cluster.g_query.get_stake_pools()
+        assert pool_ids, "No registered stake pools available on this testnet"
+        pool_id = pool_ids[0]
+
+        # Generate legacy delegation cert via compatible CLI
+        era_api = getattr(cluster.g_compatible, era)
+        legacy_stake_deleg_cert = era_api.stake_address.gen_delegation_cert(
+            name=f"{temp_template}_{era}_deleg",
+            stake_vkey_file=pool_user.stake.vkey_file,
+            stake_pool_id=pool_id,
+        )
+
+        tx_files = clusterlib.TxFiles(
+            certificate_files=[legacy_stake_deleg_cert],
+            signing_key_files=[
+                pool_user.payment.skey_file,
+                pool_user.stake.skey_file,
+            ],
+        )
+
+        with pytest.raises(clusterlib.CLIError) as excinfo:
+            cluster.g_transaction.send_tx(
+                src_address=pool_user.payment.address,
+                tx_name=f"{temp_template}_{era}_legacy_deleg",
+                tx_files=tx_files,
+            )
+
+        err = str(excinfo.value)
+        assert "TextEnvelope type error" in err, err
diff --git a/cardano_node_tests/tests/test_pools.py b/cardano_node_tests/tests/test_pools.py
index bc80573ba..718ea8361 100644
--- a/cardano_node_tests/tests/test_pools.py
+++ b/cardano_node_tests/tests/test_pools.py
@@ -2529,6 +2529,150 @@ def test_stake_pool_long_metadata_url(
             in err_str
         )
 
+    @allure.link(helpers.get_vcs_link())
+    @pytest.mark.parametrize("era", ("shelley", "allegra", "mary", "alonzo", "babbage"))
+    @pytest.mark.testnets
+    @pytest.mark.smoke
+    def test_legacy_pool_registration_rejected_in_conway(
+        self,
+        cluster_manager: cluster_management.ClusterManager,
+        cluster: clusterlib.ClusterLib,
+        era: str,
+    ):
+        """Reject legacy stake pool registration in Conway.
+
+        * Generate a stake pool registration certificate using the compatible CLI
+        for a legacy era.
+        * Attempt to submit the legacy certificate in a Conway-era transaction.
+        * Expect the transaction submission to fail with a TextEnvelope type error.
+        """
+        temp_template = common.get_test_id(cluster)
+
+        pool_users = common.get_pool_users(
+            name_template=f"{temp_template}_{era}_legacy",
+            cluster_manager=cluster_manager,
+            cluster_obj=cluster,
+            num=1,
+            fund_idx=[0],
+            amount=600_000_000,
+        )
+
+        node_vrf = cluster.g_node.gen_vrf_key_pair(f"{temp_template}_{era}_vrf")
+        node_cold = cluster.g_node.gen_cold_key_pair_and_counter(f"{temp_template}_{era}_cold")
+
+        era_api = getattr(cluster.g_compatible, era)
+
+        legacy_pool_reg_cert = era_api.stake_pool.gen_registration_cert(
+            name=f"{temp_template}_{era}_pool",
+            pool_data=clusterlib.PoolData(
+                pool_name=f"{temp_template}_{era}_pool",
+                pool_pledge=5,
+                pool_cost=cluster.g_query.get_protocol_params().get("minPoolCost", 500),
+                pool_margin=0.01,
+            ),
+            vrf_vkey_file=node_vrf.vkey_file,
+            cold_vkey_file=node_cold.vkey_file,
+            owner_stake_vkey_files=[pool_users[0].stake.vkey_file],
+        )
+
+        tx_files = clusterlib.TxFiles(
+            certificate_files=[legacy_pool_reg_cert],
+            signing_key_files=[
+                pool_users[0].payment.skey_file,
+                pool_users[0].stake.skey_file,
+                node_cold.skey_file,
+            ],
+        )
+
+        with pytest.raises(clusterlib.CLIError) as excinfo:
+            cluster.g_transaction.send_tx(
+                src_address=pool_users[0].payment.address,
+                tx_name=f"{temp_template}_{era}_legacy_pool_reg",
+                tx_files=tx_files,
+            )
+
+        err = str(excinfo.value)
+
+        assert "TextEnvelope type error" in err, err
+
+    @allure.link(helpers.get_vcs_link())
+    @pytest.mark.parametrize("era", ("shelley", "allegra", "mary", "alonzo", "babbage"))
+    @pytest.mark.testnets
+    @pytest.mark.smoke
+    def test_legacy_pool_registration_plus_conway_delegation_fails(
+        self,
+        cluster_manager: cluster_management.ClusterManager,
+        cluster: clusterlib.ClusterLib,
+        era: str,
+    ):
+        """Reject mixed legacy pool registration and Conway delegation.
+
+        * Generate a legacy stake pool registration certificate using compatible CLI.
+        * Generate a Conway-era stake address delegation certificate.
+        * Submit both certificates in a single Conway-era transaction.
+        * Expect the transaction submission to fail with a TextEnvelope type error.
+        """
+        temp_template = common.get_test_id(cluster)
+
+        # Pool user for funding and signing
+        pool_users = common.get_pool_users(
+            name_template=f"{temp_template}_{era}_mixed",
+            cluster_manager=cluster_manager,
+            cluster_obj=cluster,
+            num=1,
+            fund_idx=[0],
+            amount=600_000_000,
+        )
+
+        payment_rec = pool_users[0].payment
+        stake_rec = pool_users[0].stake
+
+        # Generate pool keys
+        node_vrf = cluster.g_node.gen_vrf_key_pair(f"{temp_template}_{era}_vrf")
+        node_cold = cluster.g_node.gen_cold_key_pair_and_counter(f"{temp_template}_{era}_cold")
+
+        # Legacy (compatible-era) pool registration certificate
+        era_api = getattr(cluster.g_compatible, era)
+        legacy_pool_reg_cert = era_api.stake_pool.gen_registration_cert(
+            name=f"{temp_template}_{era}_legacy_pool",
+            pool_data=clusterlib.PoolData(
+                pool_name=f"{temp_template}_{era}_legacy_pool",
+                pool_pledge=5,
+                pool_cost=cluster.g_query.get_protocol_params().get("minPoolCost", 500),
+                pool_margin=0.01,
+            ),
+            vrf_vkey_file=node_vrf.vkey_file,
+            cold_vkey_file=node_cold.vkey_file,
+            owner_stake_vkey_files=[stake_rec.vkey_file],
+        )
+
+        # Conway-era stake delegation certificate
+        conway_deleg_cert = cluster.g_stake_address.gen_stake_addr_delegation_cert(
+            addr_name=f"{temp_template}_{era}_deleg",
+            stake_vkey_file=stake_rec.vkey_file,
+            cold_vkey_file=node_cold.vkey_file,
+        )
+
+        tx_files = clusterlib.TxFiles(
+            certificate_files=[legacy_pool_reg_cert, conway_deleg_cert],
+            signing_key_files=[
+                payment_rec.skey_file,
+                stake_rec.skey_file,
+                node_cold.skey_file,
+            ],
+        )
+
+        with pytest.raises(clusterlib.CLIError) as excinfo:
+            cluster.g_transaction.send_tx(
+                src_address=payment_rec.address,
+                tx_name=f"{temp_template}_{era}_legacy_plus_conway_fail",
+                tx_files=tx_files,
+            )
+
+        err = str(excinfo.value)
+
+        assert "TextEnvelope type error" in err, err
+
 
 @pytest.mark.skipif(
     VERSIONS.transaction_era < VERSIONS.CONWAY, reason="runs only with Tx era >= Conway"
diff --git a/cardano_node_tests/tests/tests_conway/test_conway.py b/cardano_node_tests/tests/tests_conway/test_conway.py
index 94e7dca34..d0d4fe9d2 100644
--- a/cardano_node_tests/tests/tests_conway/test_conway.py
+++ b/cardano_node_tests/tests/tests_conway/test_conway.py
@@ -184,3 +184,60 @@ def test_ratify_state_fields(self, cluster: clusterlib.ClusterLib):
 
         missing = expected_fields - set(ratify_state)
         assert not missing, f"Missing expected fields in ratify-state: {missing}"
+
+
+class TestNegativeLegacyGovernance:
+    @allure.link(helpers.get_vcs_link())
+    @pytest.mark.parametrize("era", ("shelley", "allegra", "mary", "alonzo", "babbage"))
+    @pytest.mark.smoke
+    def test_mixed_legacy_govaction_and_conway_vote_cert_fails(
+        self,
+        cluster: clusterlib.ClusterLib,
+        pool_user: clusterlib.PoolUser,
+        era: str,
+    ):
+        """Reject mixed legacy governance action and Conway vote delegation.
+
+        * Generate a legacy governance action using the compatible CLI.
+        * Generate a Conway-era stake and vote delegation certificate.
+        * Submit both certificates in a single Conway-era transaction.
+        * Expect the transaction submission to fail with a TextEnvelope type error.
+        """
+        temp_template = common.get_test_id(cluster)
+
+        payment_rec = pool_user.payment
+        stake_rec = pool_user.stake
+
+        pool_ids = cluster.g_query.get_stake_pools()
+        assert pool_ids, "No stake pools available on this testnet"
+        pool_id = pool_ids[0]
+
+        era_api = getattr(cluster.g_compatible, era)
+        legacy_prop = era_api.governance.gen_pparams_update(
+            name=temp_template,
+            epoch=cluster.g_query.get_epoch(),
+            genesis_vkey_file=cluster.g_genesis.genesis_keys.genesis_vkeys[0],
+            cli_args=["--max-block-body-size", "65536"],
+        )
+
+        conway_vote = cluster.g_stake_address.gen_stake_and_vote_delegation_cert(
+            addr_name=f"{temp_template}_vote",
+            stake_vkey_file=stake_rec.vkey_file,
+            stake_pool_id=pool_id,
+            always_abstain=True,
+        )
+
+        tx_files = clusterlib.TxFiles(
+            certificate_files=[legacy_prop, conway_vote],
+            signing_key_files=[payment_rec.skey_file, stake_rec.skey_file],
+        )
+
+        with pytest.raises(clusterlib.CLIError) as excinfo:
+            cluster.g_transaction.send_tx(
+                src_address=payment_rec.address,
+                tx_name=f"{temp_template}_mixed_fail",
+                tx_files=tx_files,
+            )
+
+        err = str(excinfo.value)
+        assert "TextEnvelope type error" in err, err
diff --git a/cardano_node_tests/tests/tests_conway/test_pparam_update.py b/cardano_node_tests/tests/tests_conway/test_pparam_update.py
index aaa35a308..a1cec6c37 100644
--- a/cardano_node_tests/tests/tests_conway/test_pparam_update.py
+++ b/cardano_node_tests/tests/tests_conway/test_pparam_update.py
@@ -1436,57 +1436,52 @@ def test_pparam_keys(
 class TestLegacyProposals:
     """Tests for legacy update proposals in Conway."""
 
-    @pytest.fixture(scope="class")
-    def skip_on_missing_legacy(self) -> None:
-        if not clusterlib_utils.cli_has("legacy governance"):
-            pytest.skip("`legacy governance` commands are not available")
-
     @allure.link(helpers.get_vcs_link())
     @submit_utils.PARAM_SUBMIT_METHOD
+    @pytest.mark.parametrize("era", ("shelley", "allegra", "mary", "alonzo", "babbage"))
     @pytest.mark.smoke
     def test_legacy_proposal_submit(
         self,
-        skip_on_missing_legacy: None,  # noqa: ARG002
         cluster: clusterlib.ClusterLib,
         payment_addr: clusterlib.AddressRecord,
         submit_method: str,
+        era: str,
     ):
-        """Test submitting a legacy update proposal in Conway.
+        """Reject legacy update proposal submission in Conway.
 
-        Expect failure as the legacy update proposals are not supported in Conway.
+        * Generate a legacy update proposal using the compatible CLI.
+        * Attempt to submit the proposal in a Conway-era transaction.
+        * Expect the transaction submission to fail with a TextEnvelope type error.
         """
-        # TODO: convert to use
-        # `compatible babbage governance action create-protocol-parameters-update`
+        era_valid_pparam = {
+            "shelley": ("--max-block-body-size", 65536, "maxBlockBodySize"),
+            "allegra": ("--max-block-body-size", 65536, "maxBlockBodySize"),
+            "mary": ("--max-block-body-size", 65536, "maxBlockBodySize"),
+            "alonzo": ("--max-collateral-inputs", 4, "maxCollateralInputs"),
+            "babbage": ("--max-collateral-inputs", 4, "maxCollateralInputs"),
+        }
+
         temp_template = common.get_test_id(cluster)
 
+        arg, val, name = era_valid_pparam[era]
+
         update_proposals = [
             clusterlib_utils.UpdateProposal(
-                arg="--max-collateral-inputs",
-                value=4,
-                name="maxCollateralInputs",
+                arg=arg,
+                value=val,
+                name=name,
             ),
         ]
 
         cli_args = clusterlib_utils.get_pparams_update_args(update_proposals=update_proposals)
-        out_file = f"{temp_template}_update.proposal"
 
-        cluster.cli(
-            [
-                "cardano-cli",
-                "legacy",
-                "governance",
-                "create-update-proposal",
-                *cli_args,
-                "--out-file",
-                str(out_file),
-                "--epoch",
-                str(cluster.g_query.get_epoch()),
-                *helpers.prepend_flag(
-                    "--genesis-verification-key-file",
-                    cluster.g_genesis.genesis_keys.genesis_vkeys,
-                ),
-            ],
-            add_default_args=False,
+        era_api = getattr(cluster.g_compatible, era)
+
+        action_file = era_api.governance.gen_pparams_update(
+            name=temp_template,
+            epoch=cluster.g_query.get_epoch(),
+            genesis_vkey_file=cluster.g_genesis.genesis_keys.genesis_vkeys[0],
+            cli_args=cli_args,
         )
 
         with pytest.raises((clusterlib.CLIError, submit_api.SubmitApiError)) as excinfo:
@@ -1496,60 +1491,16 @@ def test_legacy_proposal_submit(
                 src_address=payment_addr.address,
                 submit_method=submit_method,
                 tx_files=clusterlib.TxFiles(
-                    proposal_files=[out_file],
+                    proposal_files=[action_file],
                     signing_key_files=[
                         *cluster.g_genesis.genesis_keys.delegate_skeys,
                         pl.Path(payment_addr.skey_file),
                     ],
                 ),
             )
-        err_str = str(excinfo.value)
-        assert 'TextEnvelopeType "UpdateProposalShelley"' in err_str, err_str
-
-    @allure.link(helpers.get_vcs_link())
-    @pytest.mark.smoke
-    def test_legacy_proposal_build(
-        self,
-        cluster: clusterlib.ClusterLib,
-    ):
-        """Test building a legacy update proposal with Conway cardano-cli.
 
-        Expect failure as the legacy update proposals are not supported in Conway.
-        """
-        temp_template = common.get_test_id(cluster)
-
-        update_proposals = [
-            clusterlib_utils.UpdateProposal(
-                arg="--max-collateral-inputs",
-                value=4,
-                name="maxCollateralInputs",
-            ),
-        ]
-
-        cli_args = clusterlib_utils.get_pparams_update_args(update_proposals=update_proposals)
-        out_file = f"{temp_template}_update.proposal"
-
-        with pytest.raises(clusterlib.CLIError) as excinfo:
-            cluster.cli(
-                [
-                    "cardano-cli",
-                    "conway",
-                    "governance",
-                    "create-update-proposal",
-                    *cli_args,
-                    "--out-file",
-                    str(out_file),
-                    "--epoch",
-                    str(cluster.g_query.get_epoch()),
-                    *helpers.prepend_flag(
-                        "--genesis-verification-key-file",
-                        cluster.g_genesis.genesis_keys.genesis_vkeys,
-                    ),
-                ],
-                add_default_args=False,
-            )
-        err_str = str(excinfo.value)
-        assert "Invalid argument `create-update-proposal'" in err_str, err_str
+        err = str(excinfo.value)
+        assert "TextEnvelope type error" in err, err
 
 
 class TestNegativeCostModels:
diff --git a/cardano_node_tests/tests/tests_conway/test_treasury_withdrawals.py b/cardano_node_tests/tests/tests_conway/test_treasury_withdrawals.py
index 0f5592f1f..80a192c53 100644
--- a/cardano_node_tests/tests/tests_conway/test_treasury_withdrawals.py
+++ b/cardano_node_tests/tests/tests_conway/test_treasury_withdrawals.py
@@ -11,7 +11,6 @@
 from cardano_node_tests.tests import common
 from cardano_node_tests.tests import reqs_conway as reqc
 from cardano_node_tests.tests.tests_conway import conway_common
-from cardano_node_tests.utils import cluster_nodes
 from cardano_node_tests.utils import clusterlib_utils
 from cardano_node_tests.utils import configuration
 from cardano_node_tests.utils import dbsync_utils
@@ -718,83 +717,67 @@ def test_expire_treasury_withdrawals(
 
 
 class TestMIRCerts:
-    """Tests for MIR certificates."""
-
-    @pytest.fixture(scope="class")
-    def skip_on_missing_legacy(self) -> None:
-        if not clusterlib_utils.cli_has("legacy governance"):
-            pytest.skip("`legacy governance` commands are not available")
+    """Tests for MIR certificates in all compatible eras."""
 
     @pytest.fixture
-    def payment_addr(
-        self,
-        skip_on_missing_legacy: None,  # noqa: ARG002
-        cluster_manager: cluster_management.ClusterManager,
-        cluster: clusterlib.ClusterLib,
-    ) -> clusterlib.AddressRecord:
-        """Create new payment address."""
-        addr = common.get_payment_addr(
+    def payment_addr(self, cluster_manager, cluster):
+        return common.get_payment_addr(
             name_template=common.get_test_id(cluster),
             cluster_manager=cluster_manager,
             cluster_obj=cluster,
             caching_key=helpers.get_current_line_str(),
             amount=4_000_000,
         )
-        return addr
 
     @allure.link(helpers.get_vcs_link())
+    @pytest.mark.parametrize("era", ("shelley", "allegra", "mary", "alonzo", "babbage"))
     @pytest.mark.parametrize(
-        "mir_cert", ("to_treasury", "to_rewards", "treasury_to_addr", "reserves_to_addr")
+        "mir_cert",
+        ("to_treasury", "to_rewards", "treasury_to_addr", "reserves_to_addr"),
     )
-    @pytest.mark.smoke
-    def test_mir_certificates(
-        self,
-        skip_on_missing_legacy: None,  # noqa: ARG002
-        cluster: clusterlib.ClusterLib,
-        payment_addr: clusterlib.AddressRecord,
-        mir_cert: str,
-    ):
-        """Try to use MIR certificates in Conway+ eras.
-
-        Expect failure.
+    def test_mir_certificates(self, cluster, payment_addr, era, mir_cert):
+        """Try each MIR certificate across all compatible eras.
 
-        * try and fail to build the Tx using `transaction build`
-        * successfully build the Tx as Babbage Tx using `transaction build-raw`
-        * try and fail to submit the Babbage Tx
+        * Conway build fails with MIR (TextEnvelope type error).
+        * Compatible-era signed transaction builds successfully.
+        * Submitting a non-Conway transaction in Conway fails due to era mismatch.
         """
-        # TODO: convert to use `compatible babbage governance create-mir-certificate`
         temp_template = common.get_test_id(cluster)
         amount = 1_500_000
 
         reqc.cip070.start(url=helpers.get_vcs_link())
 
+        # Get compatible governance for selected era dynamically
+        gov = getattr(cluster.g_compatible, era).governance
+
+        # Generate cert based on MIR type
         if mir_cert == "to_treasury":
-            cert_file = cluster.g_legacy_governance.gen_mir_cert_to_treasury(
+            cert_file = gov.gen_mir_cert_to_treasury(
+                name=temp_template,
                 transfer=amount,
-                tx_name=temp_template,
             )
         elif mir_cert == "to_rewards":
-            cert_file = cluster.g_legacy_governance.gen_mir_cert_to_rewards(
+            cert_file = gov.gen_mir_cert_to_rewards(
+                name=temp_template,
                 transfer=amount,
-                tx_name=temp_template,
             )
         elif mir_cert == "treasury_to_addr":
-            cert_file = cluster.g_legacy_governance.gen_mir_cert_stake_addr(
-                tx_name=temp_template,
-                stake_addr="stake_test1uzy5myemjnne3gr0jp7yhtznxx2lvx4qgv730jktsu46v5gaw7rmt",
+            cert_file = gov.gen_mir_cert_stake_addr(
+                name=temp_template,
+                stake_address="stake_test1uzy5myemjnne3gr0jp7yhtznxx2lvx4qgv730jktsu46v5gaw7rmt",
                 reward=amount,
                 use_treasury=True,
             )
         elif mir_cert == "reserves_to_addr":
-            cert_file = cluster.g_legacy_governance.gen_mir_cert_stake_addr(
-                tx_name=temp_template,
-                stake_addr="stake_test1uzy5myemjnne3gr0jp7yhtznxx2lvx4qgv730jktsu46v5gaw7rmt",
+            cert_file = gov.gen_mir_cert_stake_addr(
+                name=temp_template,
+                stake_address="stake_test1uzy5myemjnne3gr0jp7yhtznxx2lvx4qgv730jktsu46v5gaw7rmt",
                 reward=amount,
                 use_treasury=False,
             )
         else:
-            _verr = f"Unknown MIR cert scenario: {mir_cert}"
-            raise ValueError(_verr)
+            msg = f"Unknown MIR certificate type: {mir_cert}"
+            raise ValueError(msg)
 
         tx_files = clusterlib.TxFiles(
             certificate_files=[cert_file],
@@ -804,38 +787,32 @@ def test_mir_certificates(
             ],
         )
 
-        # The Tx cannot be build in Conway using `build`
+        # Conway build MUST fail
         with pytest.raises(clusterlib.CLIError) as excinfo:
             cluster.g_transaction.build_tx(
                 tx_name=temp_template,
                 src_address=payment_addr.address,
                 tx_files=tx_files,
             )
-        err_build = str(excinfo.value)
-        assert "TextEnvelope type error:" in err_build, err_build
-
-        # The Tx can be build as Babbage Tx using `build-raw`, but cannot be submitted.
-        # TODO: convert to use `compatible babbage transaction signed-transaction`
-        if clusterlib_utils.cli_has("babbage transaction build-raw"):
-            cluster_babbage = cluster_nodes.get_cluster_type().get_cluster_obj(
-                command_era="babbage"
-            )
-            tx_output = cluster_babbage.g_transaction.build_raw_tx(
-                tx_name=temp_template,
-                src_address=payment_addr.address,
-                fee=400_000,
-                tx_files=tx_files,
-            )
+        assert "TextEnvelope type error" in str(excinfo.value)
+
+        # Build signed tx using compatible <era> transaction command
+        tx_builder = getattr(cluster.g_compatible, era).transaction
+        signed_tx = tx_builder.gen_signed_tx(
+            name=temp_template,
+            src_address=payment_addr.address,
+            txouts=[],
+            tx_files=tx_files,
+            fee=400_000,
+        )
 
-            out_file_signed = cluster.g_transaction.sign_tx(
-                tx_body_file=tx_output.out_file,
-                signing_key_files=tx_files.signing_key_files,
-                tx_name=temp_template,
+        # Submitting non-Conway tx in Conway MUST fail
+        with pytest.raises(clusterlib.CLIError) as excinfo:
+            cluster.g_transaction.submit_tx(
+                tx_file=signed_tx.out_file,
+                txins=signed_tx.txins,
             )
-
-            with pytest.raises(clusterlib.CLIError) as excinfo:
-                cluster.g_transaction.submit_tx(tx_file=out_file_signed, txins=tx_output.txins)
-            err_submit = str(excinfo.value)
-            assert "Error: The era of the node and the tx do not match." in err_submit, err_submit
+        err = str(excinfo.value)
+        assert "era" in err or "mismatch" in err
 
         reqc.cip070.success()