diff --git a/tests/e2e/btrfs/btrfs_test.go b/tests/e2e/btrfs/btrfs_test.go
index 8ffb7ee6ea..e99d7c0e99 100644
--- a/tests/e2e/btrfs/btrfs_test.go
+++ b/tests/e2e/btrfs/btrfs_test.go
@@ -45,12 +45,8 @@ var _ = Describe("Verify that btrfs based servers work", Ordered, func() {
 
 		It("Checks node and pod status", func() {
 			By("Fetching Nodes status")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "620s", "5s").Should(Succeed())
 			e2e.DumpPods(tc.KubeconfigFile)
 
diff --git a/tests/e2e/dualstack/dualstack_test.go b/tests/e2e/dualstack/dualstack_test.go
index 9e5e10050f..176289a5eb 100644
--- a/tests/e2e/dualstack/dualstack_test.go
+++ b/tests/e2e/dualstack/dualstack_test.go
@@ -49,15 +49,10 @@ var _ = Describe("Verify DualStack Configuration", Ordered, func() {
 		})
 
 		It("Checks Node Status", func() {
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "620s", "5s").Should(Succeed())
-			_, err := e2e.ParseNodes(tc.KubeconfigFile, true)
-			Expect(err).NotTo(HaveOccurred())
+			e2e.DumpNodes(tc.KubeconfigFile)
 		})
 
 		It("Checks pod status", func() {
diff --git a/tests/e2e/embeddedmirror/embeddedmirror_test.go b/tests/e2e/embeddedmirror/embeddedmirror_test.go
index a10642eb47..b51376df30 100644
--- a/tests/e2e/embeddedmirror/embeddedmirror_test.go
+++ b/tests/e2e/embeddedmirror/embeddedmirror_test.go
@@ -53,12 +53,8 @@ var _ = Describe("Verify Create", Ordered, func() {
 		})
 		It("Checks node and pod status", func() {
 			By("Fetching Nodes status")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "620s", "5s").Should(Succeed())
 
 			By("Fetching pod status")
diff --git a/tests/e2e/externalip/externalip_test.go b/tests/e2e/externalip/externalip_test.go
index 928305d776..d4cb4ba1cc 100644
--- a/tests/e2e/externalip/externalip_test.go
+++ b/tests/e2e/externalip/externalip_test.go
@@ -74,15 +74,10 @@ var _ = Describe("Verify External-IP config", Ordered, func() {
 		})
 
 		It("Checks Node Status", func() {
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "620s", "5s").Should(Succeed())
-			_, err := e2e.ParseNodes(tc.KubeconfigFile, true)
-			Expect(err).NotTo(HaveOccurred())
+			e2e.DumpNodes(tc.KubeconfigFile)
 		})
 
 		It("Checks pod status", func() {
diff --git a/tests/e2e/privateregistry/privateregistry_test.go b/tests/e2e/privateregistry/privateregistry_test.go
index 3dd7b52746..dd678c4ee4 100644
--- a/tests/e2e/privateregistry/privateregistry_test.go
+++ b/tests/e2e/privateregistry/privateregistry_test.go
@@ -55,12 +55,8 @@ var _ = Describe("Verify Create", Ordered, func() {
 		})
 		It("Checks node and pod status", func() {
 			By("Fetching Nodes status")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "620s", "5s").Should(Succeed())
 			e2e.DumpPods(tc.KubeconfigFile)
 
diff --git a/tests/e2e/rootless/rootless_test.go b/tests/e2e/rootless/rootless_test.go
index 80fa4afa1d..ba854d027a 100644
--- a/tests/e2e/rootless/rootless_test.go
+++ b/tests/e2e/rootless/rootless_test.go
@@ -101,14 +101,10 @@ var _ = Describe("Various Startup Configurations", Ordered, func() {
 
 		It("Checks node and pod status", func() {
 			By("Fetching Nodes status")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "360s", "5s").Should(Succeed())
-			_, _ = e2e.ParseNodes(tc.KubeconfigFile, false)
+			e2e.DumpNodes(tc.KubeconfigFile)
 
 			Eventually(func() error {
 				return tests.AllPodsUp(tc.KubeconfigFile)
diff --git a/tests/e2e/rotateca/rotateca_test.go b/tests/e2e/rotateca/rotateca_test.go
index dd692c90ce..161392a573 100644
--- a/tests/e2e/rotateca/rotateca_test.go
+++ b/tests/e2e/rotateca/rotateca_test.go
@@ -50,14 +50,10 @@ var _ = Describe("Verify Custom CA Rotation", Ordered, func() {
 
 		It("Checks node and pod status", func() {
 			By("Fetching Nodes status")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "620s", "5s").Should(Succeed())
-			e2e.ParseNodes(tc.KubeconfigFile, true)
+			e2e.DumpNodes(tc.KubeconfigFile)
 
 			Eventually(func() error {
 				return tests.AllPodsUp(tc.KubeconfigFile)
@@ -92,13 +88,9 @@ var _ = Describe("Verify Custom CA Rotation", Ordered, func() {
 		})
 
 		It("Checks node and pod status", func() {
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
-			}, "420s", "5s").Should(Succeed())
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
+			}, "360s", "5s").Should(Succeed())
 
 			Eventually(func() error {
 				return tests.AllPodsUp(tc.KubeconfigFile)
diff --git a/tests/e2e/s3/s3_test.go b/tests/e2e/s3/s3_test.go
index d4b75108e5..d1551bcb69 100644
--- a/tests/e2e/s3/s3_test.go
+++ b/tests/e2e/s3/s3_test.go
@@ -52,14 +52,10 @@ var _ = Describe("Verify Create", Ordered, func() {
 		})
 		It("Checks node and pod status", func() {
 			By("Fetching Nodes status")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "620s", "5s").Should(Succeed())
-			e2e.ParseNodes(tc.KubeconfigFile, true)
+			e2e.DumpNodes(tc.KubeconfigFile)
 
 			Eventually(func() error {
 				return tests.AllPodsUp(tc.KubeconfigFile)
diff --git a/tests/e2e/secretsencryption/secretsencryption_test.go b/tests/e2e/secretsencryption/secretsencryption_test.go
index 5c0f336fad..913c717ad3 100644
--- a/tests/e2e/secretsencryption/secretsencryption_test.go
+++ b/tests/e2e/secretsencryption/secretsencryption_test.go
@@ -54,14 +54,10 @@ var _ = Describe("Verify Secrets Encryption Rotation", Ordered, func() {
 
 		It("Checks node and pod status", func() {
 			By("Fetching Nodes status")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "620s", "5s").Should(Succeed())
-			e2e.ParseNodes(tc.KubeconfigFile, true)
+			e2e.DumpNodes(tc.KubeconfigFile)
 
 			Eventually(func() error {
 				return tests.AllPodsUp(tc.KubeconfigFile)
diff --git a/tests/e2e/secretsencryption_old/secretsencryption_test.go b/tests/e2e/secretsencryption_old/secretsencryption_test.go
index 365e09b0b8..36d2f40da7 100644
--- a/tests/e2e/secretsencryption_old/secretsencryption_test.go
+++ b/tests/e2e/secretsencryption_old/secretsencryption_test.go
@@ -51,12 +51,8 @@ var _ = Describe("Verify Secrets Encryption Rotation", Ordered, func() {
 
 		It("Checks node and pod status", func() {
 			By("Fetching Nodes status")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "620s", "5s").Should(Succeed())
 
 			Eventually(func() error {
@@ -103,13 +99,9 @@ var _ = Describe("Verify Secrets Encryption Rotation", Ordered, func() {
 		})
 
 		It("Checks node and pod status", func() {
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
-			}, "420s", "5s").Should(Succeed())
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
+			}, "360s", "5s").Should(Succeed())
 
 			Eventually(func() error {
 				return tests.AllPodsUp(tc.KubeconfigFile)
diff --git a/tests/e2e/splitserver/splitserver_test.go b/tests/e2e/splitserver/splitserver_test.go
index 27c225c796..8ec77a4d86 100644
--- a/tests/e2e/splitserver/splitserver_test.go
+++ b/tests/e2e/splitserver/splitserver_test.go
@@ -126,6 +126,7 @@ var (
 	etcdNodes  []e2e.VagrantNode
 	cpNodes    []e2e.VagrantNode
 	agentNodes []e2e.VagrantNode
+	allNodes   []e2e.VagrantNode
 )
 
 var _ = ReportAfterEach(e2e.GenReport)
@@ -150,13 +151,11 @@ var _ = Describe("Verify Create", Ordered, func() {
 		})
 
 		It("Checks node and pod status", func() {
+			allNodes = append(cpNodes, etcdNodes...)
+			allNodes = append(allNodes, agentNodes...)
 			By("Fetching Nodes status")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(allNodes))
 			}, "620s", "5s").Should(Succeed())
 
 			Eventually(func() error {
@@ -248,7 +247,7 @@ var _ = Describe("Verify Create", Ordered, func() {
 			Eventually(func(g Gomega) {
 				count, err := e2e.GetDaemonsetReady("test-daemonset", tc.KubeconfigFile)
 				g.Expect(err).NotTo(HaveOccurred())
-				g.Expect(cpNodes).To(HaveLen(count), "Daemonset pod count does not match cp node count")
+				g.Expect(cpNodes).To(HaveLen(count), "Daemonset pod count does not match node count")
 			}, "240s", "10s").Should(Succeed())
 		})
 
@@ -275,8 +274,6 @@ var _ = AfterEach(func() {
 })
 
 var _ = AfterSuite(func() {
-	allNodes := append(cpNodes, etcdNodes...)
-	allNodes = append(allNodes, agentNodes...)
 	if failed {
 		AddReportEntry("journald-logs", e2e.TailJournalLogs(1000, allNodes))
 	} else {
diff --git a/tests/e2e/startup/startup_test.go b/tests/e2e/startup/startup_test.go
index af1004cff1..242b99364a 100644
--- a/tests/e2e/startup/startup_test.go
+++ b/tests/e2e/startup/startup_test.go
@@ -116,13 +116,9 @@ var _ = Describe("Various Startup Configurations", Ordered, func() {
 		})
 
 		It("Checks node and pod status", func() {
-			fmt.Printf("\nFetching node status\n")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			By("Fetching node status")
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "360s", "5s").Should(Succeed())
 			Eventually(func() error {
 				return tests.AllPodsUp(tc.KubeconfigFile)
@@ -186,12 +182,8 @@ var _ = Describe("Various Startup Configurations", Ordered, func() {
 
 		It("Checks node and pod status", func() {
 			By("Fetching node status")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "360s", "5s").Should(Succeed())
 			Eventually(func() error {
 				return tests.AllPodsUp(tc.KubeconfigFile)
@@ -228,13 +220,9 @@ var _ = Describe("Various Startup Configurations", Ordered, func() {
 		})
 
 		It("Checks node and pod status", func() {
-			fmt.Printf("\nFetching node status\n")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			By("Fetching node status")
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "360s", "5s").Should(Succeed())
 
 			Eventually(func() error {
@@ -264,13 +252,9 @@ var _ = Describe("Various Startup Configurations", Ordered, func() {
 		})
 
 		It("Checks node and pod status", func() {
-			fmt.Printf("\nFetching node status\n")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			By("Fetching node status")
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "360s", "5s").Should(Succeed())
 
 			Eventually(func() error {
@@ -300,13 +284,9 @@ var _ = Describe("Various Startup Configurations", Ordered, func() {
 		})
 
 		It("Checks node and pod status", func() {
-			fmt.Printf("\nFetching node status\n")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			By("Fetching node status")
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.Agents))
 			}, "360s", "5s").Should(Succeed())
 
 			Eventually(func() error {
diff --git a/tests/e2e/svcpoliciesandfirewall/svcpoliciesandfirewall_test.go b/tests/e2e/svcpoliciesandfirewall/svcpoliciesandfirewall_test.go
index 1639bfc9d2..b8a3079ab1 100644
--- a/tests/e2e/svcpoliciesandfirewall/svcpoliciesandfirewall_test.go
+++ b/tests/e2e/svcpoliciesandfirewall/svcpoliciesandfirewall_test.go
@@ -57,16 +57,10 @@ var _ = Describe("Verify Services Traffic policies and firewall config", Ordered
 		})
 
 		It("Checks Node Status", func() {
-			Eventually(func(g Gomega) {
-				var err error
-				nodes, err = e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
-			}, "300s", "5s").Should(Succeed())
-			_, err := e2e.ParseNodes(tc.KubeconfigFile, true)
-			Expect(err).NotTo(HaveOccurred())
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
+			}, "360s", "5s").Should(Succeed())
+			e2e.DumpNodes(tc.KubeconfigFile)
 		})
 
 		It("Checks Pod Status", func() {
diff --git a/tests/e2e/tailscale/tailscale_test.go b/tests/e2e/tailscale/tailscale_test.go
index 27dd9c1a89..3e53df59c6 100644
--- a/tests/e2e/tailscale/tailscale_test.go
+++ b/tests/e2e/tailscale/tailscale_test.go
@@ -6,6 +6,7 @@ import (
 	"os"
 	"testing"
 
+	"github.com/k3s-io/k3s/tests"
 	"github.com/k3s-io/k3s/tests/e2e"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -46,16 +47,11 @@ var _ = Describe("Verify Tailscale Configuration", Ordered, func() {
 	})
 
 	// Server node needs to be ready before we continue
-	It("Checks Node Status", func() {
-		Eventually(func(g Gomega) {
-			nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-			g.Expect(err).NotTo(HaveOccurred())
-			for _, node := range nodes {
-				g.Expect(node.Status).Should(Equal("Ready"))
-			}
-		}, "300s", "5s").Should(Succeed())
-		_, err := e2e.ParseNodes(tc.KubeconfigFile, true)
-		Expect(err).NotTo(HaveOccurred())
+	It("Checks Server Status", func() {
+		Eventually(func() error {
+			return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.Servers))
+		}, "360s", "5s").Should(Succeed())
+		e2e.DumpNodes(tc.KubeconfigFile)
 	})
 
 	It("Change agent's config", func() {
@@ -73,16 +69,10 @@ var _ = Describe("Verify Tailscale Configuration", Ordered, func() {
 	})
 
 	It("Checks Node Status", func() {
-		Eventually(func(g Gomega) {
-			nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-			g.Expect(err).NotTo(HaveOccurred())
-			g.Expect(len(nodes)).To(Equal(*agentCount + *serverCount))
-			for _, node := range nodes {
-				g.Expect(node.Status).Should(Equal("Ready"))
-			}
-		}, "300s", "5s").Should(Succeed())
-		_, err := e2e.ParseNodes(tc.KubeconfigFile, true)
-		Expect(err).NotTo(HaveOccurred())
+		Eventually(func() error {
+			return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
+		}, "360s", "5s").Should(Succeed())
+		e2e.DumpNodes(tc.KubeconfigFile)
 	})
 
 	It("Verifies that server and agent have a tailscale IP as nodeIP", func() {
diff --git a/tests/e2e/testutils.go b/tests/e2e/testutils.go
index 9d9cc1c4f9..be26dad021 100644
--- a/tests/e2e/testutils.go
+++ b/tests/e2e/testutils.go
@@ -161,13 +161,12 @@ func CreateCluster(nodeOS string, serverCount, agentCount int) (*TestConfig, err
 		return nil, err
 	}
 
-	// For startup test, we don't start the cluster, so check first before
-	// generating the kubeconfig file
+	// For startup test, we don't start the cluster, so check first before generating the kubeconfig file.
+	// Systemctl returns a exit code of 3 when the service is inactive, so we don't check for errors
+	// on the command itself.
 	var kubeConfigFile string
-	res, err := serverNodes[0].RunCmdOnNode("systemctl is-active k3s")
-	if err != nil {
-		return nil, err
-	}
+	var err error
+	res, _ := serverNodes[0].RunCmdOnNode("systemctl is-active k3s")
 	if !strings.Contains(res, "inactive") && strings.Contains(res, "active") {
 		kubeConfigFile, err = GenKubeconfigFile(serverNodes[0].String())
 		if err != nil {
@@ -491,37 +490,10 @@ func GetVagrantLog(cErr error) string {
 	return string(bytes) + nodeJournal
 }
 
-func ParseNodes(kubeConfig string, print bool) ([]Node, error) {
-	nodes := make([]Node, 0, 10)
-	nodeList := ""
-
+func DumpNodes(kubeConfig string) {
 	cmd := "kubectl get nodes --no-headers -o wide -A --kubeconfig=" + kubeConfig
-	res, err := RunCommand(cmd)
-
-	if err != nil {
-		return nil, fmt.Errorf("unable to get nodes: %s: %v", res, err)
-	}
-	nodeList = strings.TrimSpace(res)
-	split := strings.Split(nodeList, "\n")
-	for _, rec := range split {
-		if strings.TrimSpace(rec) != "" {
-			fields := strings.Fields(rec)
-			node := Node{
-				Name:       fields[0],
-				Status:     fields[1],
-				Roles:      fields[2],
-				InternalIP: fields[5],
-			}
-			if len(fields) > 6 {
-				node.ExternalIP = fields[6]
-			}
-			nodes = append(nodes, node)
-		}
-	}
-	if print {
-		fmt.Println(nodeList)
-	}
-	return nodes, nil
+	res, _ := RunCommand(cmd)
+	fmt.Println(strings.TrimSpace(res))
 }
 
 func DumpPods(kubeConfig string) {
diff --git a/tests/e2e/upgradecluster/upgradecluster_test.go b/tests/e2e/upgradecluster/upgradecluster_test.go
index 0395de6878..68252294da 100644
--- a/tests/e2e/upgradecluster/upgradecluster_test.go
+++ b/tests/e2e/upgradecluster/upgradecluster_test.go
@@ -55,12 +55,8 @@ var _ = Describe("Verify Upgrade", Ordered, func() {
 
 		It("Checks node and pod status", func() {
 			By("Fetching Nodes status")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "620s", "5s").Should(Succeed())
 
 			Eventually(func() error {
@@ -149,8 +145,7 @@ var _ = Describe("Verify Upgrade", Ordered, func() {
 			_, err := tc.DeployWorkload("daemonset.yaml")
 			Expect(err).NotTo(HaveOccurred(), "Daemonset manifest not deployed")
 
-			nodes, _ := e2e.ParseNodes(tc.KubeconfigFile, false)
-
+			nodes, _ := tests.ParseNodes(tc.KubeconfigFile)
 			Eventually(func(g Gomega) {
 				count, err := e2e.GetDaemonsetReady("test-daemonset", tc.KubeconfigFile)
 				g.Expect(err).NotTo(HaveOccurred())
@@ -239,14 +234,10 @@ var _ = Describe("Verify Upgrade", Ordered, func() {
 
 		It("After upgrade Checks Node and Pod Status", func() {
 			By("Fetching Nodes status")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
-			}, "420s", "5s").Should(Succeed())
-			e2e.ParseNodes(tc.KubeconfigFile, true)
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
+			}, "360s", "5s").Should(Succeed())
+			e2e.DumpNodes(tc.KubeconfigFile)
 
 			By("Fetching Pod status")
 			tests.AllPodsUp(tc.KubeconfigFile)
@@ -321,8 +312,7 @@ var _ = Describe("Verify Upgrade", Ordered, func() {
 		})
 
 		It("After upgrade verifies Daemonset", func() {
-			nodes, _ := e2e.ParseNodes(tc.KubeconfigFile, false)
-
+			nodes, _ := tests.ParseNodes(tc.KubeconfigFile)
 			Eventually(func(g Gomega) {
 				count, err := e2e.GetDaemonsetReady("test-daemonset", tc.KubeconfigFile)
 				g.Expect(err).NotTo(HaveOccurred())
diff --git a/tests/e2e/validatecluster/validatecluster_test.go b/tests/e2e/validatecluster/validatecluster_test.go
index 8ccdfcb016..fc4f7c9719 100644
--- a/tests/e2e/validatecluster/validatecluster_test.go
+++ b/tests/e2e/validatecluster/validatecluster_test.go
@@ -12,6 +12,7 @@ import (
 	"github.com/k3s-io/k3s/tests/e2e"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
+	corev1 "k8s.io/api/core/v1"
 )
 
 // Valid nodeOS:
@@ -58,14 +59,10 @@ var _ = Describe("Verify Create", Ordered, func() {
 
 		It("Checks node and pod status", func() {
 			fmt.Printf("\nFetching node status\n")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "620s", "5s").Should(Succeed())
-			_, _ = e2e.ParseNodes(tc.KubeconfigFile, true)
+			e2e.DumpNodes(tc.KubeconfigFile)
 
 			fmt.Printf("\nFetching Pods status\n")
 			Eventually(func() error {
@@ -171,8 +168,7 @@ var _ = Describe("Verify Create", Ordered, func() {
 			_, err := tc.DeployWorkload("daemonset.yaml")
 			Expect(err).NotTo(HaveOccurred(), "Daemonset manifest not deployed")
 
-			nodes, _ := e2e.ParseNodes(tc.KubeconfigFile, false)
-
+			nodes, _ := tests.ParseNodes(tc.KubeconfigFile)
 			Eventually(func(g Gomega) {
 				count, err := e2e.GetDaemonsetReady("test-daemonset", tc.KubeconfigFile)
 				g.Expect(err).NotTo(HaveOccurred())
@@ -262,10 +258,14 @@ var _ = Describe("Verify Create", Ordered, func() {
 			Expect(errRestart).NotTo(HaveOccurred(), "Restart Nodes not happened correctly")
 
 			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
+				nodes, err := tests.ParseNodes(tc.KubeconfigFile)
 				g.Expect(err).NotTo(HaveOccurred())
 				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
+					for _, condition := range node.Status.Conditions {
+						if condition.Type == corev1.NodeReady {
+							g.Expect(condition.Status).Should(Equal(corev1.ConditionTrue))
+						}
+					}
 				}
 				count, err := e2e.GetDaemonsetReady("test-daemonset", tc.KubeconfigFile)
 				g.Expect(err).NotTo(HaveOccurred())
diff --git a/tests/e2e/wasm/wasm_test.go b/tests/e2e/wasm/wasm_test.go
index 02bce94d86..4ba6b47850 100644
--- a/tests/e2e/wasm/wasm_test.go
+++ b/tests/e2e/wasm/wasm_test.go
@@ -47,12 +47,8 @@ var _ = Describe("Verify K3s can run Wasm workloads", Ordered, func() {
 
 		It("Checks node and pod status", func() {
 			By("Fetching Nodes status")
-			Eventually(func(g Gomega) {
-				nodes, err := e2e.ParseNodes(tc.KubeconfigFile, false)
-				g.Expect(err).NotTo(HaveOccurred())
-				for _, node := range nodes {
-					g.Expect(node.Status).Should(Equal("Ready"))
-				}
+			Eventually(func() error {
+				return tests.NodesReady(tc.KubeconfigFile, e2e.VagrantSlice(tc.AllNodes()))
 			}, "620s", "5s").Should(Succeed())
 
 			By("Fetching pod status")