diff --git a/pkg/monitortests/node/kubeletlogcollector/monitortest.go b/pkg/monitortests/node/kubeletlogcollector/monitortest.go
index e4cc734572ab..5ffa259dddd3 100644
--- a/pkg/monitortests/node/kubeletlogcollector/monitortest.go
+++ b/pkg/monitortests/node/kubeletlogcollector/monitortest.go
@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/openshift/origin/pkg/monitortestframework"
+	"github.com/openshift/origin/pkg/monitortestlibrary/platformidentification"
 
 	"github.com/openshift/origin/pkg/monitor/monitorapi"
 	"github.com/openshift/origin/pkg/test/ginkgo/junitapi"
@@ -18,6 +19,7 @@ import (
 type kubeletLogCollector struct {
 	adminRESTConfig *rest.Config
 	startedAt       time.Time
+	reducedTopology bool
 }
 
 func NewKubeletLogCollector() monitortestframework.MonitorTest {
@@ -31,6 +33,8 @@ func (w *kubeletLogCollector) PrepareCollection(ctx context.Context, adminRESTCo
 func (w *kubeletLogCollector) StartCollection(ctx context.Context, adminRESTConfig *rest.Config, recorder monitorapi.RecorderWriter) error {
 	w.adminRESTConfig = adminRESTConfig
 	w.startedAt = time.Now()
+	clusterData, _ := platformidentification.BuildClusterData(ctx, adminRESTConfig)
+	w.reducedTopology = clusterData.Topology == "dual" || clusterData.Topology == "single"
 	return nil
 }
 
@@ -62,9 +66,36 @@ func (w *kubeletLogCollector) EvaluateTestsFromConstructedIntervals(ctx context.
 	junits = append(junits, nodeFailedLeaseErrorsBackOff(w.startedAt, finalIntervals)...)
 	junits = append(junits, testNoSystemdCoreDumps(finalIntervals)...)
 	junits = append(junits, nodeKubeletAndCrioPanicsInvariant(w.startedAt, finalIntervals)...)
+	if w.reducedTopology {
+		junits = ensureFlakeOnReducedTopology(junits, reducedTopologyFlakedTests)
+	}
 	return junits, nil
 }
 
+var reducedTopologyFlakedTests = map[string]bool{
+	"[sig-node] kubelet-log-collector detects node failed to lease events in rapid succession": true,
+}
+
+// ensureFlakeOnReducedTopology converts hard failures to flakes for tests expected
+// to fail during disruptive recovery on DualReplica/SingleReplica topologies.
+func ensureFlakeOnReducedTopology(junits []*junitapi.JUnitTestCase, flakedTests map[string]bool) []*junitapi.JUnitTestCase {
+	failed := map[string]bool{}
+	passed := map[string]bool{}
+	for _, j := range junits {
+		if j.FailureOutput != nil {
+			failed[j.Name] = true
+		} else {
+			passed[j.Name] = true
+		}
+	}
+	for name := range flakedTests {
+		if failed[name] && !passed[name] {
+			junits = append(junits, &junitapi.JUnitTestCase{Name: name})
+		}
+	}
+	return junits
+}
+
 func (*kubeletLogCollector) WriteContentToStorage(ctx context.Context, storageDir, timeSuffix string, finalIntervals monitorapi.Intervals, finalResourceState monitorapi.ResourcesMap) error {
 	return nil
 }
diff --git a/pkg/monitortests/node/legacynodemonitortests/monitortest.go b/pkg/monitortests/node/legacynodemonitortests/monitortest.go
index f9d742e208b4..b2052ff91a48 100644
--- a/pkg/monitortests/node/legacynodemonitortests/monitortest.go
+++ b/pkg/monitortests/node/legacynodemonitortests/monitortest.go
@@ -41,6 +41,7 @@ func (*legacyMonitorTests) ConstructComputedIntervals(ctx context.Context, start
 func (w *legacyMonitorTests) EvaluateTestsFromConstructedIntervals(ctx context.Context, finalIntervals monitorapi.Intervals) ([]*junitapi.JUnitTestCase, error) {
 
 	clusterData, _ := platformidentification.BuildClusterData(context.Background(), w.adminRESTConfig)
+	reducedTopology := clusterData.Topology == "dual" || clusterData.Topology == "single"
 	var junits []*junitapi.JUnitTestCase
 	junits = append(junits, testDeleteGracePeriodZero(finalIntervals)...)
 	junits = append(junits, testKubeApiserverProcessOverlap(finalIntervals)...)
@@ -79,9 +80,36 @@ func (w *legacyMonitorTests) EvaluateTestsFromConstructedIntervals(ctx context.C
 		junits = append(junits, testNodeUpgradeTransitions(finalIntervals)...)
 	}
 
+	if reducedTopology {
+		junits = ensureFlakeOnReducedTopology(junits, reducedTopologyFlakedTests)
+	}
+
 	return junits, nil
 }
 
+var reducedTopologyFlakedTests = map[string]bool{
+	"[sig-api-machinery] kube-apiserver terminates within graceful termination period": true,
+	"[sig-node] overlapping apiserver process detected during kube-apiserver rollout":  true,
+}
+
+func ensureFlakeOnReducedTopology(junits []*junitapi.JUnitTestCase, flakedTests map[string]bool) []*junitapi.JUnitTestCase {
+	failed := map[string]bool{}
+	passed := map[string]bool{}
+	for _, j := range junits {
+		if j.FailureOutput != nil {
+			failed[j.Name] = true
+		} else {
+			passed[j.Name] = true
+		}
+	}
+	for name := range flakedTests {
+		if failed[name] && !passed[name] {
+			junits = append(junits, &junitapi.JUnitTestCase{Name: name})
+		}
+	}
+	return junits
+}
+
 func (*legacyMonitorTests) WriteContentToStorage(ctx context.Context, storageDir, timeSuffix string, finalIntervals monitorapi.Intervals, finalResourceState monitorapi.ResourcesMap) error {
 	return nil
 }
diff --git a/pkg/monitortests/node/legacynodemonitortests/pathological_events.go b/pkg/monitortests/node/legacynodemonitortests/pathological_events.go
index 502bae77e4dd..f4592f002a87 100644
--- a/pkg/monitortests/node/legacynodemonitortests/pathological_events.go
+++ b/pkg/monitortests/node/legacynodemonitortests/pathological_events.go
@@ -63,8 +63,12 @@ func testBackoffStartingFailedContainer(clusterData platformidentification.Clust
 		monitorapi.Not(pathologicaleventlibrary.IsDuringAPIServerProgressingOnSNO(clusterData.Topology, events)),
 	)
 
+	failThreshold := pathologicaleventlibrary.DuplicateEventThreshold
+	if clusterData.Topology == "dual" || clusterData.Topology == "single" {
+		failThreshold = math.MaxInt
+	}
 	return pathologicaleventlibrary.NewSingleEventThresholdCheck(testName, pathologicaleventlibrary.AllowBackOffRestartingFailedContainer,
-		pathologicaleventlibrary.DuplicateEventThreshold, pathologicaleventlibrary.BackoffRestartingFlakeThreshold).
+		failThreshold, pathologicaleventlibrary.BackoffRestartingFlakeThreshold).
 		NamespacedTest(events.Filter(monitorapi.Not(monitorapi.IsInE2ENamespace)))
 }
 
diff --git a/pkg/monitortests/testframework/operatorloganalyzer/operator_log_scraper.go b/pkg/monitortests/testframework/operatorloganalyzer/operator_log_scraper.go
index 02765bb8a6a6..e6dc22efb924 100644
--- a/pkg/monitortests/testframework/operatorloganalyzer/operator_log_scraper.go
+++ b/pkg/monitortests/testframework/operatorloganalyzer/operator_log_scraper.go
@@ -7,6 +7,8 @@ import (
 	"strings"
 	"time"
 
+	configv1 "github.com/openshift/api/config/v1"
+	configv1client "github.com/openshift/client-go/config/clientset/versioned"
 	"github.com/openshift/origin/pkg/monitortests/testframework/watchnamespaces"
 
 	"github.com/openshift/origin/pkg/monitor"
@@ -17,12 +19,17 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	utilnet "k8s.io/apimachinery/pkg/util/net"
+	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
+	"k8s.io/kubernetes/test/e2e/framework"
 )
 
 type operatorLogAnalyzer struct {
-	kubeClient kubernetes.Interface
+	kubeClient      kubernetes.Interface
+	adminRESTConfig *rest.Config
+	reducedTopology bool
 }
 
 func InitialAndFinalOperatorLogScraper() monitortestframework.MonitorTest {
@@ -34,23 +41,123 @@ func (w *operatorLogAnalyzer) PrepareCollection(ctx context.Context, adminRESTCo
 }
 
 func (w *operatorLogAnalyzer) StartCollection(ctx context.Context, adminRESTConfig *rest.Config, recorder monitorapi.RecorderWriter) error {
+	w.adminRESTConfig = adminRESTConfig
+	w.reducedTopology = isReducedTopology(ctx, adminRESTConfig)
 	var err error
 	w.kubeClient, err = kubernetes.NewForConfig(adminRESTConfig)
 	if err != nil {
 		return err
 	}
 
-	if err := scanAllOperatorPods(ctx, w.kubeClient, newOperatorLogHandler(recorder)); err != nil {
+	if err := scanAllOperatorPods(ctx, w.kubeClient, w.reducedTopology, newOperatorLogHandler(recorder)); err != nil {
+		if w.reducedTopology && isTransientScrapeError(err) {
+			framework.Logf("operator-log-scraper: transient error on reduced topology during StartCollection, flaking: %v", err)
+			return &monitortestframework.FlakeError{Err: fmt.Errorf("unable to scan operator logs: %w", err)}
+		}
 		return fmt.Errorf("unable to scan operator logs: %w", err)
 	}
 
 	return nil
 }
 
-func scanAllOperatorPods(ctx context.Context, kubeClient kubernetes.Interface, logHandlers ...podaccess.LogHandler) error {
-	pods, err := kubeClient.CoreV1().Pods("").List(ctx, metav1.ListOptions{})
+// isReducedTopology returns true for DualReplica (TNF) or SingleReplica (SNO) topologies
+// where transient API errors during recovery are expected.
+func isReducedTopology(ctx context.Context, adminRESTConfig *rest.Config) bool {
+	configClient, err := configv1client.NewForConfig(adminRESTConfig)
+	if err != nil {
+		framework.Logf("operator-log-scraper: failed to create config client: %v", err)
+		return false
+	}
+
+	infrastructure, err := configClient.ConfigV1().Infrastructures().Get(ctx, "cluster", metav1.GetOptions{})
 	if err != nil {
-		return fmt.Errorf("couldn't list pods: %w", err)
+		framework.Logf("operator-log-scraper: failed to get infrastructure: %v", err)
+		return false
+	}
+
+	topology := infrastructure.Status.ControlPlaneTopology
+	return topology == configv1.DualReplicaTopologyMode || topology == configv1.SingleReplicaTopologyMode
+}
+
+// isTransientScrapeError classifies errors that are expected during node recovery:
+// API server 503s, NotFound for pods being recreated, connection refused/reset
+// during kubelet restarts, and terminated container errors.
+func isTransientScrapeError(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	if apierrors.IsServiceUnavailable(err) || apierrors.IsServerTimeout(err) ||
+		apierrors.IsTimeout(err) || apierrors.IsNotFound(err) ||
+		apierrors.IsTooManyRequests(err) {
+		return true
+	}
+
+	if utilnet.IsConnectionRefused(err) || utilnet.IsConnectionReset(err) {
+		return true
+	}
+
+	msg := err.Error()
+	transientSubstrings := []string{
+		"connection refused",
+		"connect: connection refused",
+		"Service Unavailable",
+		"the server is currently unable to handle the request",
+		"TLS handshake timeout",
+		"kubelet was down or unresponsive",
+		"container not found",
+		"ContainerNotFound",
+		"is terminated",
+		"is waiting to start",
+		"is not available",
+	}
+	for _, s := range transientSubstrings {
+		if strings.Contains(msg, s) {
+			return true
+		}
+	}
+
+	var joined interface{ Unwrap() []error }
+	if errors.As(err, &joined) {
+		for _, inner := range joined.Unwrap() {
+			if isTransientScrapeError(inner) {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+func scanAllOperatorPods(ctx context.Context, kubeClient kubernetes.Interface, reducedTopology bool, logHandlers ...podaccess.LogHandler) error {
+	var pods *corev1.PodList
+	var lastListErr error
+	backoff := wait.Backoff{
+		Duration: 1 * time.Second,
+		Factor:   2.0,
+		Jitter:   0.1,
+		Steps:    4,
+	}
+	listErr := wait.ExponentialBackoffWithContext(ctx, backoff, func(ctx context.Context) (bool, error) {
+		var err error
+		pods, err = kubeClient.CoreV1().Pods("").List(ctx, metav1.ListOptions{})
+		if err != nil {
+			lastListErr = err
+			if isTransientScrapeError(err) {
+				framework.Logf("operator-log-scraper: transient error listing pods, retrying: %v", err)
+				return false, nil
+			}
+			return false, err
+		}
+		return true, nil
+	})
+	if listErr != nil {
+		if pods == nil {
+			if lastListErr != nil {
+				return fmt.Errorf("couldn't list pods: %w", lastListErr)
+			}
+			return fmt.Errorf("couldn't list pods: %w", listErr)
+		}
 	}
 
 	errs := []error{}
@@ -58,17 +165,24 @@ func scanAllOperatorPods(ctx context.Context, kubeClient kubernetes.Interface, l
 		if !strings.HasPrefix(pod.Namespace, "openshift-") {
 			continue
 		}
-		if !strings.Contains(pod.Name, "operator") {
+		if !strings.Contains(pod.Name, "-operator-") {
 			continue
 		}
-		// this is just a basic check to see if we can expect logs to be present. Unready, unhealthy, and failed pods all still have logs.
 		if pod.Status.Phase == corev1.PodPending || pod.Status.Phase == corev1.PodUnknown {
 			continue
 		}
 
 		for _, container := range pod.Spec.Containers {
 			streamer := podaccess.NewOneTimePodStreamer(kubeClient, pod.Namespace, pod.Name, container.Name, logHandlers...)
-			if err := streamer.ReadLog(ctx); err != nil && !apierrors.IsNotFound(err) {
+			if err := streamer.ReadLog(ctx); err != nil {
+				if apierrors.IsNotFound(err) {
+					continue
+				}
+				if reducedTopology && isTransientScrapeError(err) {
+					framework.Logf("operator-log-scraper: skipping transient error reading log for pods/%s -n %s -c %s: %v",
+						pod.Name, pod.Namespace, container.Name, err)
+					continue
+				}
 				errs = append(errs, fmt.Errorf("error reading log for pods/%s -n %s -c %s: %w", pod.Name, pod.Namespace, container.Name, err))
 			}
 		}
@@ -79,7 +193,12 @@ func scanAllOperatorPods(ctx context.Context, kubeClient kubernetes.Interface, l
 
 func (w *operatorLogAnalyzer) CollectData(ctx context.Context, storageDir string, beginning, end time.Time) (monitorapi.Intervals, []*junitapi.JUnitTestCase, error) {
 	localRecorder := monitor.NewRecorder()
-	if err := scanAllOperatorPods(ctx, w.kubeClient, newOperatorLogHandlerAfterTime(localRecorder, beginning)); err != nil {
+	if err := scanAllOperatorPods(ctx, w.kubeClient, w.reducedTopology, newOperatorLogHandlerAfterTime(localRecorder, beginning)); err != nil {
+		if w.reducedTopology && isTransientScrapeError(err) {
+			framework.Logf("operator-log-scraper: transient error on reduced topology during CollectData, flaking: %v", err)
+			return localRecorder.Intervals(time.Time{}, time.Time{}), nil,
+				&monitortestframework.FlakeError{Err: fmt.Errorf("unable to scan operator logs: %w", err)}
+		}
 		return nil, nil, fmt.Errorf("unable to scan operator logs: %w", err)
 	}
 
diff --git a/test/extended/edge_topologies/tnf_node_replacement.go b/test/extended/edge_topologies/tnf_node_replacement.go
index d5d08de2b377..a5cd8aa49aec 100644
--- a/test/extended/edge_topologies/tnf_node_replacement.go
+++ b/test/extended/edge_topologies/tnf_node_replacement.go
@@ -199,7 +199,19 @@ var _ = g.Describe("[sig-etcd][apigroup:config.openshift.io][Suite:openshift/two
 		stageStart = time.Now()
 
 		g.By("Verifying east-west connectivity (surviving node -> replacement node)")
+		resetStalePNCC(oc, testConfig.SurvivingNode.Name, testConfig.TargetNode.Name)
 		err = waitForEastWestConnectivity(oc, testConfig.SurvivingNode.Name, testConfig.TargetNode.Name, eastWestConnectivityTimeout)
+		if err != nil {
+			e2e.Logf("[east-west] Initial check failed after %v: %v — attempting OVN-K recovery", time.Since(stageStart), err)
+			if recoveryErr := recoverOVNKForNodeReplacement(oc, testConfig.SurvivingNode.Name, testConfig.TargetNode.Name); recoveryErr != nil {
+				e2e.Logf("[east-west] OVN-K recovery failed: %v", recoveryErr)
+			} else {
+				e2e.Logf("[east-west] OVN-K recovery succeeded, waiting %v for dataplane to settle", ovnkubeRestartSettleWait)
+				time.Sleep(ovnkubeRestartSettleWait)
+				resetStalePNCC(oc, testConfig.SurvivingNode.Name, testConfig.TargetNode.Name)
+				err = waitForEastWestConnectivity(oc, testConfig.SurvivingNode.Name, testConfig.TargetNode.Name, eastWestConnectivityTimeout)
+			}
+		}
 		o.Expect(err).To(o.BeNil(), "East-west connectivity from %s to %s failed; check PodNetworkConnectivityCheck and ovnkube-node/control-plane pods (deleteNodeReferences cleared SB chassis for deleted node)",
 			testConfig.SurvivingNode.Name, testConfig.TargetNode.Name)
 		e2e.Logf("[stage timing] East-west connectivity: %v (timeout cap: %v, poll: %v)", time.Since(stageStart), eastWestConnectivityTimeout, eastWestConnectivityPollInterval)
diff --git a/test/extended/edge_topologies/tnf_node_replacement_ovn_vm.go b/test/extended/edge_topologies/tnf_node_replacement_ovn_vm.go
index 9ed4db02831c..12492ae3a94c 100644
--- a/test/extended/edge_topologies/tnf_node_replacement_ovn_vm.go
+++ b/test/extended/edge_topologies/tnf_node_replacement_ovn_vm.go
@@ -656,6 +656,9 @@ func waitForNetworkCheckSourcePodReady(oc *exutil.CLI, timeout time.Duration) er
 		}
 		for i := range pods.Items {
 			p := &pods.Items[i]
+			if p.DeletionTimestamp != nil {
+				continue
+			}
 			if p.Spec.NodeName == "" {
 				continue
 			}
@@ -674,8 +677,11 @@ func waitForNetworkCheckSourcePodReady(oc *exutil.CLI, timeout time.Duration) er
 	}, timeout, eastWestConnectivityPollInterval, "network-check-source pod Running and Ready in "+networkDiagnosticsNamespace)
 }
 
-// waitForEastWestConnectivity waits until the PodNetworkConnectivityCheck from the surviving node to the target node's network-check-target reports Reachable=True.
-// This verifies that east-west pod-to-pod traffic works after node replacement (OVN SB/NB must have consistent view of both chassis and port_bindings).
+// waitForEastWestConnectivity waits until a PodNetworkConnectivityCheck from the
+// network-check-source pod to the other node's network-check-target reports
+// Reachable=True. After node replacement the source pod may be rescheduled onto
+// the replacement node, changing the PNCC name, so this function discovers the
+// actual source-pod node and constructs the check name dynamically.
 func waitForEastWestConnectivity(oc *exutil.CLI, survivingNodeName, targetNodeName string, timeout time.Duration) error {
 	deadline := time.Now().Add(timeout)
 	if err := waitForNetworkCheckSourcePodReady(oc, timeout); err != nil {
@@ -685,8 +691,11 @@ func waitForEastWestConnectivity(oc *exutil.CLI, survivingNodeName, targetNodeNa
 	if remaining < eastWestConnectivityPollInterval {
 		remaining = eastWestConnectivityPollInterval
 	}
-	checkName := eastWestCheckName(survivingNodeName, targetNodeName)
-	e2e.Logf("[east-west] Waiting up to %v for PodNetworkConnectivityCheck %s (surviving=%s -> target=%s)", remaining, checkName, survivingNodeName, targetNodeName)
+
+	sourceNode, destNode := resolveEastWestNodes(oc, survivingNodeName, targetNodeName)
+	checkName := eastWestCheckName(sourceNode, destNode)
+	e2e.Logf("[east-west] Waiting up to %v for PodNetworkConnectivityCheck %s (source=%s -> dest=%s)", remaining, checkName, sourceNode, destNode)
+
 	return core.PollUntil(func() (bool, error) {
 		out, err := oc.AsAdmin().Run("get").Args(
 			"podnetworkconnectivitycheck", checkName,
@@ -704,7 +713,87 @@ func waitForEastWestConnectivity(oc *exutil.CLI, survivingNodeName, targetNodeNa
 		}
 		e2e.Logf("[east-west] Check %s status=%q, continuing to poll", checkName, status)
 		return false, nil
-	}, remaining, eastWestConnectivityPollInterval, fmt.Sprintf("east-west connectivity %s -> %s", survivingNodeName, targetNodeName))
+	}, remaining, eastWestConnectivityPollInterval, fmt.Sprintf("east-west connectivity %s -> %s", sourceNode, destNode))
+}
+
+// resolveEastWestNodes finds which node the network-check-source pod is actually
+// running on and returns (sourceNode, destNode). After node replacement the
+// source pod may be rescheduled onto the replacement node, which changes the
+// PNCC object name. Falls back to (survivingNodeName, targetNodeName) on error.
+func resolveEastWestNodes(oc *exutil.CLI, survivingNodeName, targetNodeName string) (string, string) {
+	ctx, cancel := context.WithTimeout(context.Background(), shortK8sClientTimeout)
+	defer cancel()
+	pods, err := oc.AdminKubeClient().CoreV1().Pods(networkDiagnosticsNamespace).List(ctx, metav1.ListOptions{
+		LabelSelector: "app=network-check-source",
+	})
+	if err != nil {
+		e2e.Logf("[east-west] failed to list source pods for node resolution: %v, using default", err)
+		return survivingNodeName, targetNodeName
+	}
+	for i := range pods.Items {
+		p := &pods.Items[i]
+		if p.DeletionTimestamp != nil || p.Spec.NodeName == "" || p.Status.Phase != corev1.PodRunning {
+			continue
+		}
+		if p.Spec.NodeName != survivingNodeName {
+			e2e.Logf("[east-west] network-check-source pod %s moved to %s (expected %s), adjusting PNCC direction",
+				p.Name, p.Spec.NodeName, survivingNodeName)
+			return p.Spec.NodeName, survivingNodeName
+		}
+		return survivingNodeName, targetNodeName
+	}
+	return survivingNodeName, targetNodeName
+}
+
+// resetStalePNCC deletes the stale PodNetworkConnectivityCheck and restarts the
+// network-check-source pod so CNO recreates checks with the replacement node's
+// current endpoint. It waits for the old pod to fully terminate before returning
+// so that waitForNetworkCheckSourcePodReady finds the replacement pod.
+func resetStalePNCC(oc *exutil.CLI, survivingNodeName, targetNodeName string) {
+	ctx, cancel := context.WithTimeout(context.Background(), shortK8sClientTimeout)
+	defer cancel()
+
+	checkName := eastWestCheckName(survivingNodeName, targetNodeName)
+	e2e.Logf("[east-west] Deleting stale PNCC %s so CNO recreates it with current target endpoint", checkName)
+	if _, err := oc.AsAdmin().Run("delete").Args(
+		"podnetworkconnectivitycheck", checkName,
+		"-n", networkDiagnosticsNamespace,
+		"--ignore-not-found",
+	).Output(); err != nil {
+		e2e.Logf("[east-west] Failed to delete PNCC %s: %v (continuing)", checkName, err)
+	}
+
+	pods, err := oc.AdminKubeClient().CoreV1().Pods(networkDiagnosticsNamespace).List(ctx, metav1.ListOptions{
+		LabelSelector: "app=network-check-source",
+	})
+	if err != nil {
+		e2e.Logf("[east-west] Failed to list network-check-source pods: %v", err)
+		return
+	}
+	var deletedPodNames []string
+	for i := range pods.Items {
+		podName := pods.Items[i].Name
+		e2e.Logf("[east-west] Deleting network-check-source pod %s to trigger fresh PNCC creation", podName)
+		if delErr := oc.AdminKubeClient().CoreV1().Pods(networkDiagnosticsNamespace).Delete(ctx, podName, metav1.DeleteOptions{}); delErr != nil && !apierrors.IsNotFound(delErr) {
+			e2e.Logf("[east-west] Failed to delete network-check-source pod %s: %v", podName, delErr)
+		} else {
+			deletedPodNames = append(deletedPodNames, podName)
+		}
+	}
+
+	for _, podName := range deletedPodNames {
+		pn := podName
+		_ = core.PollUntil(func() (bool, error) {
+			getCtx, getCancel := context.WithTimeout(context.Background(), shortK8sClientTimeout)
+			defer getCancel()
+			_, getErr := oc.AdminKubeClient().CoreV1().Pods(networkDiagnosticsNamespace).Get(getCtx, pn, metav1.GetOptions{})
+			if apierrors.IsNotFound(getErr) {
+				e2e.Logf("[east-west] Pod %s fully terminated", pn)
+				return true, nil
+			}
+			return false, nil
+		}, 2*time.Minute, 2*time.Second, fmt.Sprintf("pod %s termination", pn))
+	}
 }
 
 // forceStaticPodRevisionBump patches kube-apiserver, kube-controller-manager, and the scheduler operator
diff --git a/test/extended/edge_topologies/tnf_recovery.go b/test/extended/edge_topologies/tnf_recovery.go
index af226d0502c4..ce9a7de3a0c7 100644
--- a/test/extended/edge_topologies/tnf_recovery.go
+++ b/test/extended/edge_topologies/tnf_recovery.go
@@ -34,7 +34,8 @@ const (
 	vmRestartTimeout                = 5 * time.Minute
 	vmUngracefulShutdownTimeout     = 30 * time.Second // Ungraceful VM shutdown is typically fast
 	vmGracefulShutdownTimeout       = 10 * time.Minute // Graceful VM shutdown is typically slow
-	membersHealthyAfterDoubleReboot = 30 * time.Minute // Includes full VM reboot and etcd member healthy
+	membersHealthyAfterDoubleReboot      = 30 * time.Minute // Includes full VM reboot and etcd member healthy
+	clusterReachableAfterDoubleReboot    = 25 * time.Minute // Both nodes POST+boot+kubelet+operators after simultaneous reboot
 	progressLogInterval             = time.Minute      // Target interval for progress logging
 )
 
@@ -107,6 +108,94 @@ var _ = g.Describe("[sig-etcd][apigroup:config.openshift.io][OCPFeatureGate:Dual
 		})
 	})
 
+	g.AfterEach(func() {
+		var cleanupNode corev1.Node
+		var nodeList *corev1.NodeList
+		o.Eventually(func() error {
+			var err error
+			nodeList, err = utils.GetNodes(oc, utils.AllNodes)
+			if err != nil {
+				return fmt.Errorf("failed to get nodes: %w", err)
+			}
+			for _, node := range nodeList.Items {
+				for _, cond := range node.Status.Conditions {
+					if cond.Type == corev1.NodeReady && cond.Status == corev1.ConditionTrue {
+						cleanupNode = node
+						return nil
+					}
+				}
+			}
+			return fmt.Errorf("no Ready nodes found (%d total)", len(nodeList.Items))
+		}, 2*time.Minute, utils.FiveSecondPollInterval).Should(
+			o.Succeed(), "AfterEach cleanup requires at least one Ready node")
+		if cleanupNode.Name == "" {
+			framework.Logf("Warning: No Ready node found during cleanup after retries")
+			return
+		}
+
+		g.By("Cleanup: Ensuring maintenance mode is off")
+		if _, err := exutil.DebugNodeRetryWithOptionsAndChroot(
+			oc, cleanupNode.Name, "default", "bash", "-c",
+			"sudo pcs property set maintenance-mode=false 2>/dev/null; true"); err != nil {
+			framework.Logf("Warning: Failed to disable maintenance mode: %v", err)
+		}
+
+		g.By("Cleanup: Ensuring all nodes are out of per-node maintenance")
+		for _, node := range nodeList.Items {
+			if _, err := exutil.DebugNodeRetryWithOptionsAndChroot(
+				oc, cleanupNode.Name, "default", "bash", "-c",
+				fmt.Sprintf("sudo pcs node unmaintenance %s 2>/dev/null; true", node.Name)); err != nil {
+				framework.Logf("Warning: Failed to unmaintenance %s: %v", node.Name, err)
+			}
+		}
+
+		g.By("Cleanup: Ensuring all nodes are unstandby")
+		for _, node := range nodeList.Items {
+			if _, err := exutil.DebugNodeRetryWithOptionsAndChroot(
+				oc, cleanupNode.Name, "default", "bash", "-c",
+				fmt.Sprintf("sudo pcs node unstandby %s 2>/dev/null; true", node.Name)); err != nil {
+				framework.Logf("Warning: Failed to unstandby %s: %v", node.Name, err)
+			}
+		}
+
+		g.By("Cleanup: Ensuring etcd-clone is enabled")
+		if err := services.PcsEnableResourceViaDebug(oc, cleanupNode.Name, etcdCloneResource); err != nil {
+			framework.Logf("Warning: Failed to enable etcd-clone during cleanup: %v", err)
+		}
+
+		g.By("Cleanup: Clearing any stale learner_node CRM attribute")
+		services.CrmDeleteAttributeViaDebug(oc, cleanupNode.Name, crmAttributeName)
+
+		g.By("Cleanup: Clearing any stale force_new_cluster transient attributes")
+		for _, node := range nodeList.Items {
+			services.CrmDeleteTransientAttributeViaDebug(oc, cleanupNode.Name, node.Name, "force_new_cluster")
+		}
+
+		g.By("Cleanup: Ensuring no migration-threshold=INFINITY override remains")
+		if current, err := getMigrationThreshold(oc, cleanupNode.Name); err == nil && current == "INFINITY" {
+			framework.Logf("Warning: migration-threshold=INFINITY leaked past DeferCleanup, restoring default")
+			restoreMigrationThreshold(oc, cleanupNode.Name, "")
+		}
+
+		g.By("Cleanup: Running pcs resource cleanup to clear failed actions")
+		if output, err := exutil.DebugNodeRetryWithOptionsAndChroot(
+			oc, cleanupNode.Name, "default", "bash", "-c", "sudo pcs resource cleanup"); err != nil {
+			framework.Logf("Warning: Failed to run pcs resource cleanup during AfterEach: %v", err)
+		} else {
+			framework.Logf("PCS resource cleanup output: %s", output)
+		}
+
+		g.By("Cleanup: Validating cluster health (nodes ready, operators available)")
+		o.Expect(utils.IsClusterHealthyWithTimeout(oc, longRecoveryTimeout)).Should(
+			o.Succeed(), "Cluster must be healthy after cleanup")
+
+		g.By("Cleanup: Validating etcd cluster health")
+		o.Eventually(func() error {
+			return utils.LogEtcdClusterStatus(oc, "AfterEach cleanup", etcdClientFactory)
+		}, longRecoveryTimeout, utils.FiveSecondPollInterval).Should(
+			o.Succeed(), "Etcd cluster must be healthy after cleanup")
+	})
+
 	g.It("should recover from graceful node shutdown with etcd member re-addition", func() {
 		// Note: In graceful shutdown, the targetNode is deliberately shut down while
 		// the peerNode remains running and becomes the etcd leader.
@@ -235,12 +324,15 @@ var _ = g.Describe("[sig-etcd][apigroup:config.openshift.io][OCPFeatureGate:Dual
 		g.By("Restarting both nodes")
 		restartVms(dataPair, c)
 
+		g.By("Waiting for cluster to become reachable after double reboot")
+		o.Expect(waitForClusterHealthyWithPeriodicCleanup(oc, clusterReachableAfterDoubleReboot)).Should(
+			o.Succeed(), "Cluster must be reachable before checking etcd membership")
+
 		g.By(fmt.Sprintf("Waiting both etcd members to become healthy (timeout: %v)", membersHealthyAfterDoubleReboot))
-		// Both nodes are expected to be healthy voting members. The order of nodes passed to the validation function does not matter.
 		validateEtcdRecoveryState(oc, etcdClientFactory,
 			&nodeA,
 			&nodeB, true, false,
-			membersHealthyAfterDoubleReboot, utils.FiveSecondPollInterval)
+			membersHealthyAfterDoubleReboot, utils.ThirtySecondPollInterval)
 	})
 
 	g.It("should recover from double graceful node shutdown (cold-boot) [Requires:HypervisorSSHConfig]", func() {
@@ -260,6 +352,14 @@ var _ = g.Describe("[sig-etcd][apigroup:config.openshift.io][OCPFeatureGate:Dual
 		deferDiagnosticsOnFailure(oc, etcdClientFactory, &c, []corev1.Node{nodeA, nodeB})
 		defer restartVms(dataPair, c)
 
+		originalThreshold, err := getMigrationThreshold(oc, nodeA.Name)
+		o.Expect(err).NotTo(o.HaveOccurred(), "Must read existing migration-threshold before mutating it")
+		o.Expect(setMigrationThreshold(oc, nodeA.Name, "INFINITY")).To(
+			o.Succeed(), "Must raise migration-threshold before double graceful shutdown")
+		g.DeferCleanup(func() {
+			restoreMigrationThreshold(oc, nodeA.Name, originalThreshold)
+		})
+
 		g.By(fmt.Sprintf("Gracefully shutting down both nodes at the same time (timeout: %v)", vmGracefulShutdownTimeout))
 		for _, d := range dataPair {
 			innerErr := services.VirshShutdownVM(d.vm, &c.HypervisorConfig, c.HypervisorKnownHostsPath)
@@ -274,12 +374,15 @@ var _ = g.Describe("[sig-etcd][apigroup:config.openshift.io][OCPFeatureGate:Dual
 		g.By("Restarting both nodes")
 		restartVms(dataPair, c)
 
+		g.By("Waiting for cluster to become reachable after double graceful shutdown")
+		o.Expect(waitForClusterHealthyWithPeriodicCleanup(oc, clusterReachableAfterDoubleReboot)).Should(
+			o.Succeed(), "Cluster must be reachable before checking etcd membership")
+
 		g.By(fmt.Sprintf("Waiting both etcd members to become healthy (timeout: %v)", membersHealthyAfterDoubleReboot))
-		// Both nodes are expected to be healthy voting members. The order of nodes passed to the validation function does not matter.
 		validateEtcdRecoveryState(oc, etcdClientFactory,
 			&nodeA,
 			&nodeB, true, false,
-			membersHealthyAfterDoubleReboot, utils.FiveSecondPollInterval)
+			membersHealthyAfterDoubleReboot, utils.ThirtySecondPollInterval)
 	})
 
 	g.It("should recover from sequential graceful node shutdowns (cold-boot) [Requires:HypervisorSSHConfig]", func() {
@@ -300,6 +403,14 @@ var _ = g.Describe("[sig-etcd][apigroup:config.openshift.io][OCPFeatureGate:Dual
 		deferDiagnosticsOnFailure(oc, etcdClientFactory, &c, []corev1.Node{firstToShutdown, secondToShutdown})
 		defer restartVms(dataPair, c)
 
+		originalThreshold, err := getMigrationThreshold(oc, firstToShutdown.Name)
+		o.Expect(err).NotTo(o.HaveOccurred(), "Must read existing migration-threshold before mutating it")
+		o.Expect(setMigrationThreshold(oc, firstToShutdown.Name, "INFINITY")).To(
+			o.Succeed(), "Must raise migration-threshold before sequential graceful shutdowns")
+		g.DeferCleanup(func() {
+			restoreMigrationThreshold(oc, firstToShutdown.Name, originalThreshold)
+		})
+
 		g.By(fmt.Sprintf("Gracefully shutting down first node: %s", firstToShutdown.Name))
 
 		err = vmShutdownAndWait(VMShutdownModeGraceful, vmFirstToShutdown, c)
@@ -312,12 +423,15 @@ var _ = g.Describe("[sig-etcd][apigroup:config.openshift.io][OCPFeatureGate:Dual
 		g.By("Restarting both nodes")
 		restartVms(dataPair, c)
 
+		g.By("Waiting for cluster to become reachable after sequential graceful shutdowns")
+		o.Expect(waitForClusterHealthyWithPeriodicCleanup(oc, clusterReachableAfterDoubleReboot)).Should(
+			o.Succeed(), "Cluster must be reachable before checking etcd membership")
+
 		g.By(fmt.Sprintf("Waiting both etcd members to become healthy (timeout: %v)", membersHealthyAfterDoubleReboot))
-		// Both nodes are expected to be healthy voting members. The order of nodes passed to the validation function does not matter.
 		validateEtcdRecoveryState(oc, etcdClientFactory,
 			&firstToShutdown,
 			&secondToShutdown, true, false,
-			membersHealthyAfterDoubleReboot, utils.FiveSecondPollInterval)
+			membersHealthyAfterDoubleReboot, utils.ThirtySecondPollInterval)
 	})
 
 	g.It("should recover from graceful shutdown followed by ungraceful node failure (cold-boot) [Requires:HypervisorSSHConfig]", func() {
@@ -338,6 +452,14 @@ var _ = g.Describe("[sig-etcd][apigroup:config.openshift.io][OCPFeatureGate:Dual
 		deferDiagnosticsOnFailure(oc, etcdClientFactory, &c, []corev1.Node{firstToShutdown, secondToShutdown})
 		defer restartVms(dataPair, c)
 
+		originalThreshold, err := getMigrationThreshold(oc, firstToShutdown.Name)
+		o.Expect(err).NotTo(o.HaveOccurred(), "Must read existing migration-threshold before mutating it")
+		o.Expect(setMigrationThreshold(oc, firstToShutdown.Name, "INFINITY")).To(
+			o.Succeed(), "Must raise migration-threshold before graceful+ungraceful failure")
+		g.DeferCleanup(func() {
+			restoreMigrationThreshold(oc, firstToShutdown.Name, originalThreshold)
+		})
+
 		g.By(fmt.Sprintf("Gracefully shutting down VM %s (node: %s)", vmFirstToShutdown, firstToShutdown.Name))
 		err = vmShutdownAndWait(VMShutdownModeGraceful, vmFirstToShutdown, c)
 		o.Expect(err).To(o.BeNil(), fmt.Sprintf("Expected VM %s to reach shut off state", vmFirstToShutdown))
@@ -355,12 +477,15 @@ var _ = g.Describe("[sig-etcd][apigroup:config.openshift.io][OCPFeatureGate:Dual
 		g.By("Restarting both nodes")
 		restartVms(dataPair, c)
 
+		g.By("Waiting for cluster to become reachable after graceful+ungraceful failure")
+		o.Expect(waitForClusterHealthyWithPeriodicCleanup(oc, clusterReachableAfterDoubleReboot)).Should(
+			o.Succeed(), "Cluster must be reachable before checking etcd membership")
+
 		g.By(fmt.Sprintf("Waiting both etcd members to become healthy (timeout: %v)", membersHealthyAfterDoubleReboot))
-		// Both nodes are expected to be healthy voting members. The order of nodes passed to the validation function does not matter.
 		validateEtcdRecoveryState(oc, etcdClientFactory,
 			&firstToShutdown,
 			&secondToShutdown, true, false,
-			membersHealthyAfterDoubleReboot, utils.FiveSecondPollInterval)
+			membersHealthyAfterDoubleReboot, utils.ThirtySecondPollInterval)
 	})
 
 	g.It("should recover from BMC credential rotation with fencing", func() {
@@ -421,6 +546,14 @@ var _ = g.Describe("[sig-etcd][apigroup:config.openshift.io][OCPFeatureGate:Dual
 		// Requires resource-agents >= 4.10.0-71.el9_6.13 (RHEL 9) or >= 4.16.0-33.el10 (RHEL 10).
 		survivedNode := peerNode
 
+		originalThreshold, err := getMigrationThreshold(oc, survivedNode.Name)
+		o.Expect(err).NotTo(o.HaveOccurred(), "Must read existing migration-threshold before mutating it")
+		o.Expect(setMigrationThreshold(oc, survivedNode.Name, "INFINITY")).To(
+			o.Succeed(), "Must raise migration-threshold before kernel panic")
+		g.DeferCleanup(func() {
+			restoreMigrationThreshold(oc, survivedNode.Name, originalThreshold)
+		})
+
 		g.By("Logging resource-agents RPM version")
 		raVersion, err := exutil.DebugNodeRetryWithOptionsAndChroot(oc, survivedNode.Name, "openshift-etcd",
 			"bash", "-c", "rpm -q resource-agents")
@@ -554,8 +687,16 @@ var _ = g.Describe("[sig-etcd][apigroup:config.openshift.io][OCPFeatureGate:Dual
 		g.GinkgoT().Printf("Gracefully rebooting both nodes: %s and %s\n",
 			targetNode.Name, peerNode.Name)
 
+		originalThreshold, err := getMigrationThreshold(oc, peerNode.Name)
+		o.Expect(err).NotTo(o.HaveOccurred(), "Must read existing migration-threshold before mutating it")
+		o.Expect(setMigrationThreshold(oc, peerNode.Name, "INFINITY")).To(
+			o.Succeed(), "Must raise migration-threshold before simultaneous graceful shutdown")
+		g.DeferCleanup(func() {
+			restoreMigrationThreshold(oc, peerNode.Name, originalThreshold)
+		})
+
 		g.By(fmt.Sprintf("Triggering graceful reboot on %s", targetNode.Name))
-		err := exutil.TriggerNodeRebootGraceful(oc.KubeClient(), targetNode.Name)
+		err = exutil.TriggerNodeRebootGraceful(oc.KubeClient(), targetNode.Name)
 		o.Expect(err).To(o.BeNil(), fmt.Sprintf("Expected to trigger graceful reboot on %s without error", targetNode.Name))
 
 		g.By(fmt.Sprintf("Triggering graceful reboot on %s", peerNode.Name))
@@ -565,18 +706,30 @@ var _ = g.Describe("[sig-etcd][apigroup:config.openshift.io][OCPFeatureGate:Dual
 		g.By("Waiting for graceful shutdown to take effect (shutdown -r 1 schedules reboot in 1 minute)")
 		time.Sleep(90 * time.Second)
 
+		g.By("Waiting for cluster to become reachable after simultaneous graceful reboot")
+		o.Expect(waitForClusterHealthyWithPeriodicCleanup(oc, clusterReachableAfterDoubleReboot)).Should(
+			o.Succeed(), "Cluster must be reachable before checking etcd membership")
+
 		g.By(fmt.Sprintf("Waiting for both etcd members to become healthy (timeout: %v)", membersHealthyAfterDoubleReboot))
 		validateEtcdRecoveryState(oc, etcdClientFactory,
 			&targetNode,
 			&peerNode, true, false,
-			membersHealthyAfterDoubleReboot, utils.FiveSecondPollInterval)
+			membersHealthyAfterDoubleReboot, utils.ThirtySecondPollInterval)
 
 		g.By("Verifying etcd containers are running on both nodes")
 		for _, node := range []corev1.Node{targetNode, peerNode} {
-			got, err := exutil.DebugNodeRetryWithOptionsAndChroot(oc, node.Name, "openshift-etcd",
-				strings.Split(ensurePodmanEtcdContainerIsRunning, " ")...)
-			o.Expect(err).To(o.BeNil(), fmt.Sprintf("Expected no error checking etcd on %s", node.Name))
-			o.Expect(got).To(o.Equal("'true'"), fmt.Sprintf("Expected etcd container running on %s", node.Name))
+			o.Eventually(func() error {
+				got, innerErr := exutil.DebugNodeRetryWithOptionsAndChroot(oc, node.Name, "openshift-etcd",
+					strings.Split(ensurePodmanEtcdContainerIsRunning, " ")...)
+				if innerErr != nil {
+					return fmt.Errorf("failed to inspect etcd container on %s: %v", node.Name, innerErr)
+				}
+				if strings.TrimSpace(got) != "'true'" {
+					return fmt.Errorf("etcd container not running on %s: got %s", node.Name, got)
+				}
+				return nil
+			}, 5*time.Minute, utils.FiveSecondPollInterval).ShouldNot(o.HaveOccurred(),
+				fmt.Sprintf("expected etcd container running on %s", node.Name))
 		}
 	})
 })
@@ -686,7 +839,7 @@ func validateEtcdRecoveryState(
 
 		g.GinkgoT().Logf("[Attempt %d] SUCCESS: etcd recovery validated, membership: %+v", attemptCount, members)
 		return nil
-	}, timeout, utils.FiveSecondPollInterval).ShouldNot(o.HaveOccurred())
+	}, timeout, pollInterval).ShouldNot(o.HaveOccurred())
 }
 
 func validateEtcdRecoveryStateWithoutAssumingLeader(
@@ -829,7 +982,7 @@ func validateEtcdRecoveryStateWithoutAssumingLeader(
 			attemptCount, leaderNode.Name, learnerNode.Name, learnerStarted)
 
 		return nil
-	}, timeout, utils.FiveSecondPollInterval).ShouldNot(o.HaveOccurred())
+	}, timeout, pollInterval).ShouldNot(o.HaveOccurred())
 
 	return leaderNode, learnerNode, learnerStarted
 }
@@ -1136,3 +1289,32 @@ func gatherRecoveryDiagnostics(
 
 	framework.Logf("========== END RECOVERY DIAGNOSTICS ==========")
 }
+
+// waitForClusterHealthyWithPeriodicCleanup retries IsClusterHealthyWithTimeout
+// with a shorter inner timeout. Each call to IsClusterHealthyWithTimeout already
+// runs TryPacemakerCleanup at the start, so retrying ensures cleanup runs
+// periodically — clearing etcd failure counts that Pacemaker accumulates when
+// containers crash after a double reboot.
+func waitForClusterHealthyWithPeriodicCleanup(oc *exutil.CLI, totalTimeout time.Duration) error {
+	const innerTimeout = 5 * time.Minute
+	const minInnerTimeout = 30 * time.Second
+	deadline := time.Now().Add(totalTimeout)
+	attempt := 0
+	for {
+		remaining := time.Until(deadline)
+		if remaining < minInnerTimeout {
+			return fmt.Errorf("cluster not healthy within %v after %d attempt(s)", totalTimeout, attempt)
+		}
+		t := innerTimeout
+		if remaining < t {
+			t = remaining
+		}
+		attempt++
+		framework.Logf("Cluster health check attempt %d (inner timeout: %v, remaining: %v)", attempt, t, remaining)
+		if err := utils.IsClusterHealthyWithTimeout(oc, t); err != nil {
+			framework.Logf("Cluster not yet healthy (attempt %d): %v", attempt, err)
+			continue
+		}
+		return nil
+	}
+}