diff --git a/go.mod b/go.mod
index 583b1897dba..aa02f1003db 100644
--- a/go.mod
+++ b/go.mod
@@ -4,6 +4,7 @@ go 1.21
 
 require (
 	fortio.org/fortio v1.63.4
+	fortio.org/log v1.12.0
 	github.com/cncf/xds/go v0.0.0-20231128003011-0fa0005c9caa
 	github.com/davecgh/go-spew v1.1.1
 	github.com/envoyproxy/go-control-plane v0.12.0
@@ -53,7 +54,6 @@ require (
 
 require (
 	fortio.org/dflag v1.7.0 // indirect
-	fortio.org/log v1.12.0 // indirect
 	fortio.org/sets v1.0.3 // indirect
 	fortio.org/struct2env v0.4.0 // indirect
 	fortio.org/version v1.0.3 // indirect
diff --git a/test/config/gatewayclass.yaml b/test/config/gatewayclass.yaml
index 65880b445f9..162a3821f92 100644
--- a/test/config/gatewayclass.yaml
+++ b/test/config/gatewayclass.yaml
@@ -62,3 +62,30 @@ spec:
   shutdown:
     drainTimeout: 5s
     minDrainDuration: 1s
+---
+kind: GatewayClass
+apiVersion: gateway.networking.k8s.io/v1
+metadata:
+  name: upgrade
+spec:
+  controllerName: gateway.envoyproxy.io/gatewayclass-controller
+  parametersRef:
+    group: gateway.envoyproxy.io
+    kind: EnvoyProxy
+    name: upgrade-config
+    namespace: envoy-gateway-system
+---
+apiVersion: gateway.envoyproxy.io/v1alpha1
+kind: EnvoyProxy
+metadata:
+  name: upgrade-config
+  namespace: envoy-gateway-system
+spec:
+  shutdown:
+    drainTimeout: 15s
+  provider:
+    type: Kubernetes
+    kubernetes:
+      envoyDeployment:
+        replicas: 2
+
diff --git a/test/e2e/base/manifests.yaml b/test/e2e/base/manifests.yaml
index 9b401cda00d..3aa0549ab2a 100644
--- a/test/e2e/base/manifests.yaml
+++ b/test/e2e/base/manifests.yaml
@@ -642,3 +642,72 @@ spec:
   - protocol: TCP
     port: 8000
     targetPort: 8000
+---
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: gateway-upgrade-infra
+---
+apiVersion: gateway.networking.k8s.io/v1
+kind: Gateway
+metadata:
+  name: ha-gateway
+  namespace: gateway-upgrade-infra
+spec:
+  gatewayClassName: upgrade
+  listeners:
+  - allowedRoutes:
+      namespaces:
+        from: Same
+    name: http1
+    port: 80
+    protocol: HTTP
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: infra-backend
+  namespace: gateway-upgrade-infra
+spec:
+  selector:
+    app: infra-backend
+  ports:
+  - protocol: TCP
+    port: 8080
+    targetPort: 3000
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: infra-backend
+  namespace: gateway-upgrade-infra
+  labels:
+    app: infra-backend
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: infra-backend
+  template:
+    metadata:
+      labels:
+        app: infra-backend
+    spec:
+      containers:
+      - name: infra-backend
+        # From https://github.com/kubernetes-sigs/gateway-api/blob/main/conformance/echo-basic/echo-basic.go
+        image: gcr.io/k8s-staging-gateway-api/echo-basic:v20231214-v1.0.0-140-gf544a46e
+        env:
+        - name: POD_NAME
+          valueFrom:
+            fieldRef:
+              fieldPath: metadata.name
+        - name: NAMESPACE
+          valueFrom:
+            fieldRef:
+              fieldPath: metadata.namespace
+        - name: SERVICE_NAME
+          value: infra-backend
+        resources:
+          requests:
+            cpu: 10m
diff --git a/test/e2e/testdata/eg-upgrade.yaml b/test/e2e/testdata/eg-upgrade.yaml
index 864ccb6a64e..3b8a9e4c726 100644
--- a/test/e2e/testdata/eg-upgrade.yaml
+++ b/test/e2e/testdata/eg-upgrade.yaml
@@ -1,38 +1,16 @@
-apiVersion: gateway.envoyproxy.io/v1alpha1
-kind: BackendTrafficPolicy
-metadata:
-  name: eg-upgrade-example
-  namespace: gateway-conformance-infra
-spec:
-  targetRef:
-    group: gateway.networking.k8s.io
-    kind: HTTPRoute
-    name: http-backend-eg-upgrade
-    namespace: gateway-conformance-infra
-  circuitBreaker:
-    maxParallelRequests: 10000
-    maxConnections: 10000
-    maxPendingRequests: 10000
-  retry:
-    retryOn:
-      triggers:
-        - connect-failure
-        - reset
-    numRetries: 10
----
 apiVersion: gateway.networking.k8s.io/v1
 kind: HTTPRoute
 metadata:
   name: http-backend-eg-upgrade
-  namespace: gateway-conformance-infra
+  namespace: gateway-upgrade-infra
 spec:
   parentRefs:
-    - name: same-namespace
+  - name: ha-gateway
   rules:
-    - matches:
-        - path:
-            type: PathPrefix
-            value: /backend-upgrade
-      backendRefs:
-        - name: infra-backend-v1
-          port: 8080
+  - matches:
+    - path:
+        type: PathPrefix
+        value: /eg-upgrade
+    backendRefs:
+    - name: infra-backend
+      port: 8080
diff --git a/test/e2e/testdata/envoy-shutdown.yaml b/test/e2e/testdata/envoy-shutdown.yaml
new file mode 100644
index 00000000000..bed43782164
--- /dev/null
+++ b/test/e2e/testdata/envoy-shutdown.yaml
@@ -0,0 +1,16 @@
+apiVersion: gateway.networking.k8s.io/v1
+kind: HTTPRoute
+metadata:
+  name: http-envoy-shutdown
+  namespace: gateway-upgrade-infra
+spec:
+  parentRefs:
+  - name: ha-gateway
+  rules:
+  - matches:
+    - path:
+        type: PathPrefix
+        value: /envoy-shutdown
+    backendRefs:
+    - name: infra-backend
+      port: 8080
diff --git a/test/e2e/tests/backend_upgrade.go b/test/e2e/tests/backend_upgrade.go
index 6119aad0f05..04aa1cc8a56 100644
--- a/test/e2e/tests/backend_upgrade.go
+++ b/test/e2e/tests/backend_upgrade.go
@@ -10,12 +10,10 @@ package tests
 
 import (
 	"context"
-	"io"
 	"net/url"
 	"testing"
 	"time"
 
-	"fortio.org/fortio/fhttp"
 	"fortio.org/fortio/periodic"
 
 	appsv1 "k8s.io/api/apps/v1"
@@ -23,8 +21,8 @@ import (
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/wait"
-	"sigs.k8s.io/controller-runtime/pkg/client"
 
+	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/gateway-api/conformance/utils/config"
 	"sigs.k8s.io/gateway-api/conformance/utils/http"
 	"sigs.k8s.io/gateway-api/conformance/utils/kubernetes"
@@ -44,10 +42,15 @@ var BackendUpgradeTest = suite.ConformanceTest{
 			ns := "gateway-conformance-infra"
 			routeNN := types.NamespacedName{Name: "http-backend-upgrade", Namespace: ns}
 			gwNN := types.NamespacedName{Name: "same-namespace", Namespace: ns}
-			dNN := types.NamespacedName{Name: "infra-backend-v1", Namespace: ns}
 			gwAddr := kubernetes.GatewayAndHTTPRoutesMustBeAccepted(t, suite.Client, suite.TimeoutConfig, suite.ControllerName, kubernetes.NewGatewayRef(gwNN), routeNN)
 			reqURL := url.URL{Scheme: "http", Host: http.CalculateHost(t, gwAddr, "http"), Path: "/backend-upgrade"}
 
+			// get deployment to restart
+			dp, err := getDeploymentByNN(ns, "infra-backend-v1", suite.Client)
+			if err != nil {
+				t.Errorf("Failed to get backend deployment")
+			}
+
 			// can be used to abort the test after deployment restart is complete or failed
 			aborter := periodic.NewAborter()
 			// will contain indication on success or failure of load test
@@ -58,7 +61,7 @@ var BackendUpgradeTest = suite.ConformanceTest{
 			go runLoadAndWait(t, suite.TimeoutConfig, loadSuccess, aborter, reqURL.String())
 
 			t.Log("Restarting deployment")
-			err := restartDeploymentAndWaitForNewPods(t, suite.TimeoutConfig, suite.Client, dNN)
+			err = restartDeploymentAndWaitForNewPods(t, suite.TimeoutConfig, suite.Client, dp)
 
 			t.Log("Stopping load generation and collecting results")
 			aborter.Abort(false) // abort the load either way
@@ -76,54 +79,19 @@ var BackendUpgradeTest = suite.ConformanceTest{
 	},
 }
 
-// runs a load test with options described in opts
-// the done channel is used to notify caller of execution result
-// the execution may end due to an external abort or timeout
-func runLoadAndWait(t *testing.T, timeoutConfig config.TimeoutConfig, done chan bool, aborter *periodic.Aborter, reqURL string) {
-	opts := fhttp.HTTPRunnerOptions{
-		RunnerOptions: periodic.RunnerOptions{
-			QPS: 5000,
-			// allow some overhead time for setting up workers and tearing down after restart
-			Duration:   timeoutConfig.CreateTimeout + timeoutConfig.CreateTimeout/2,
-			NumThreads: 50,
-			Stop:       aborter,
-			Out:        io.Discard,
-		},
-		HTTPOptions: fhttp.HTTPOptions{
-			URL: reqURL,
-		},
-	}
-	res, err := fhttp.RunHTTPTest(&opts)
-	if err != nil {
-		done <- false
-		t.Logf("failed to create load: %v", err)
-	}
-
-	// collect stats
-	okReq := res.RetCodes[200]
-	totalReq := res.DurationHistogram.Count
-	failedReq := totalReq - okReq
-	errorReq := res.ErrorsDurationHistogram.Count
-	timedOut := res.ActualDuration == opts.Duration
-	t.Logf("Backend upgrade completed after %s with %d requests, %d success, %d failures and %d errors", res.ActualDuration, totalReq, okReq, failedReq, errorReq)
+func getDeploymentByNN(namespace, name string, c client.Client) (*appsv1.Deployment, error) {
+	ctx := context.Background()
+	dp := &appsv1.Deployment{}
 
-	if okReq == totalReq && errorReq == 0 && !timedOut {
-		done <- true
-	}
-	done <- false
+	err := c.Get(ctx, types.NamespacedName{Namespace: namespace, Name: name}, dp)
+	return dp, err
 }
 
-func restartDeploymentAndWaitForNewPods(t *testing.T, timeoutConfig config.TimeoutConfig, c client.Client, dNN types.NamespacedName) error {
+func restartDeploymentAndWaitForNewPods(t *testing.T, timeoutConfig config.TimeoutConfig, c client.Client, dp *appsv1.Deployment) error {
 	t.Helper()
 	const kubeRestartAnnotation = "kubectl.kubernetes.io/restartedAt"
 
 	ctx := context.Background()
-	dp := &appsv1.Deployment{}
-
-	err := c.Get(ctx, dNN, dp)
-	if err != nil {
-		return err
-	}
 
 	if dp.Spec.Template.ObjectMeta.Annotations == nil {
 		dp.Spec.Template.ObjectMeta.Annotations = make(map[string]string)
@@ -131,7 +99,7 @@ func restartDeploymentAndWaitForNewPods(t *testing.T, timeoutConfig config.Timeo
 	restartTime := time.Now().Format(time.RFC3339)
 	dp.Spec.Template.ObjectMeta.Annotations[kubeRestartAnnotation] = restartTime
 
-	if err = c.Update(ctx, dp); err != nil {
+	if err := c.Update(ctx, dp); err != nil {
 		return err
 	}
 
@@ -139,11 +107,11 @@ func restartDeploymentAndWaitForNewPods(t *testing.T, timeoutConfig config.Timeo
 		// wait for replicaset with the same annotation to reach ready status
 		podList := &corev1.PodList{}
 		listOpts := []client.ListOption{
-			client.InNamespace(dNN.Namespace),
-			client.MatchingLabelsSelector{Selector: labels.SelectorFromSet(labels.Set{"app": dNN.Name})},
+			client.InNamespace(dp.Namespace),
+			client.MatchingLabelsSelector{Selector: labels.SelectorFromSet(dp.Spec.Selector.MatchLabels)},
 		}
 
-		err = c.List(ctx, podList, listOpts...)
+		err := c.List(ctx, podList, listOpts...)
 		if err != nil {
 			return false, err
 		}
diff --git a/test/e2e/tests/eg_upgrade.go b/test/e2e/tests/eg_upgrade.go
index 80a17b85139..ffa61d1139e 100644
--- a/test/e2e/tests/eg_upgrade.go
+++ b/test/e2e/tests/eg_upgrade.go
@@ -37,15 +37,15 @@ var EGUpgradeTest = suite.ConformanceTest{
 				lastVersionTag = "v0.6.0" // Default version tag if not specified
 			}
 
-			ns := "gateway-conformance-infra"
+			ns := "gateway-upgrade-infra"
 			routeNN := types.NamespacedName{Name: "http-backend-eg-upgrade", Namespace: ns}
-			gwNN := types.NamespacedName{Name: "same-namespace", Namespace: ns}
+			gwNN := types.NamespacedName{Name: "ha-gateway", Namespace: ns}
 			gwAddr := kubernetes.GatewayAndHTTPRoutesMustBeAccepted(t, suite.Client, suite.TimeoutConfig, suite.ControllerName, kubernetes.NewGatewayRef(gwNN), routeNN)
-			reqURL := url.URL{Scheme: "http", Host: http.CalculateHost(t, gwAddr, "http"), Path: "/backend-upgrade"}
+			reqURL := url.URL{Scheme: "http", Host: http.CalculateHost(t, gwAddr, "http"), Path: "/eg-upgrade"}
 			kubernetes.NamespacesMustBeReady(t, suite.Client, suite.TimeoutConfig, []string{depNS})
 			expectOkResp := http.ExpectedResponse{
 				Request: http.Request{
-					Path: "/backend-upgrade",
+					Path: "/eg-upgrade",
 				},
 				Response: http.Response{
 					StatusCode: 200,
diff --git a/test/e2e/tests/envoy_shutdown.go b/test/e2e/tests/envoy_shutdown.go
new file mode 100644
index 00000000000..6e870a265e6
--- /dev/null
+++ b/test/e2e/tests/envoy_shutdown.go
@@ -0,0 +1,179 @@
+// Copyright Envoy Gateway Authors
+// SPDX-License-Identifier: Apache-2.0
+// The full text of the Apache license is available in the LICENSE file at
+// the root of the repo.
+
+//go:build e2e
+// +build e2e
+
+package tests
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/url"
+	"testing"
+	"time"
+
+	"github.com/envoyproxy/gateway/api/v1alpha1"
+
+	"fortio.org/fortio/periodic"
+
+	"github.com/envoyproxy/gateway/internal/gatewayapi"
+	"github.com/envoyproxy/gateway/internal/infrastructure/kubernetes/proxy"
+
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+	v1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/wait"
+
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/gateway-api/conformance/utils/config"
+	"sigs.k8s.io/gateway-api/conformance/utils/http"
+	"sigs.k8s.io/gateway-api/conformance/utils/kubernetes"
+	"sigs.k8s.io/gateway-api/conformance/utils/suite"
+)
+
+func init() {
+	UpgradeTests = append(UpgradeTests, EnvoyShutdownTest)
+}
+
+var EnvoyShutdownTest = suite.ConformanceTest{
+	ShortName:   "EnvoyShutdown",
+	Description: "Deleting envoy pod should not lead to failures",
+	Manifests:   []string{"testdata/envoy-shutdown.yaml"},
+	Test: func(t *testing.T, suite *suite.ConformanceTestSuite) {
+		t.Run("All requests must succeed", func(t *testing.T) {
+			ns := "gateway-upgrade-infra"
+			name := "ha-gateway"
+			routeNN := types.NamespacedName{Name: "http-envoy-shutdown", Namespace: ns}
+			gwNN := types.NamespacedName{Name: name, Namespace: ns}
+			gwAddr := kubernetes.GatewayAndHTTPRoutesMustBeAccepted(t, suite.Client, suite.TimeoutConfig, suite.ControllerName, kubernetes.NewGatewayRef(gwNN), routeNN)
+			reqURL := url.URL{Scheme: "http", Host: http.CalculateHost(t, gwAddr, "http"), Path: "/envoy-shutdown"}
+			epNN := types.NamespacedName{Name: "upgrade-config", Namespace: "envoy-gateway-system"}
+			dp, err := getDeploymentForGateway(ns, name, suite.Client)
+			if err != nil {
+				t.Errorf("Failed to get proxy deployment")
+			}
+
+			// wait for route to be programmed on envoy
+			expectedResponse := http.ExpectedResponse{
+				Request: http.Request{
+					Path: "/envoy-shutdown",
+				},
+				Response: http.Response{
+					StatusCode: 200,
+				},
+				Namespace: ns,
+			}
+			http.MakeRequestAndExpectEventuallyConsistentResponse(t, suite.RoundTripper, suite.TimeoutConfig, gwAddr, expectedResponse)
+
+			// can be used to abort the test after deployment restart is complete or failed
+			aborter := periodic.NewAborter()
+			// will contain indication on success or failure of load test
+			loadSuccess := make(chan bool)
+
+			t.Log("Starting load generation")
+			// Run load async and continue to restart deployment
+			go runLoadAndWait(t, suite.TimeoutConfig, loadSuccess, aborter, reqURL.String())
+
+			t.Log("Rolling out proxy deployment")
+			err = restartProxyAndWaitForRollout(t, suite.TimeoutConfig, suite.Client, epNN, dp)
+
+			t.Log("Stopping load generation and collecting results")
+			aborter.Abort(false) // abort the load either way
+
+			if err != nil {
+				t.Errorf("Failed to rollout proxy deployment")
+			}
+
+			// Wait for the goroutine to finish
+			result := <-loadSuccess
+			if !result {
+				t.Errorf("Load test failed")
+			}
+		})
+	},
+}
+
+// gets the proxy deployment created for a gateway, assuming merge-gateways is not used
+func getDeploymentForGateway(namespace, name string, c client.Client) (*appsv1.Deployment, error) {
+	dpLabels := proxy.EnvoyAppLabel()
+	owningLabels := gatewayapi.GatewayOwnerLabels(namespace, name)
+	for k, v := range owningLabels {
+		dpLabels[k] = v
+	}
+	ctx := context.Background()
+
+	listOpts := []client.ListOption{
+		client.InNamespace("envoy-gateway-system"),
+		client.MatchingLabelsSelector{Selector: labels.SelectorFromSet(dpLabels)},
+	}
+
+	depList := &appsv1.DeploymentList{}
+	err := c.List(ctx, depList, listOpts...)
+	if err != nil {
+		return nil, err
+	}
+	if len(depList.Items) != 1 {
+		return nil, errors.New("unexpected number of matching deployments found")
+	}
+	ret := depList.Items[0]
+	return &ret, nil
+}
+
+// sets the "gateway.envoyproxy.io/restartedAt" annotation in the EnvoyProxy resource's deployment patch spec
+// leading to EG triggering a rollout restart of the deployment
+func restartProxyAndWaitForRollout(t *testing.T, timeoutConfig config.TimeoutConfig, c client.Client, epNN types.NamespacedName, dp *appsv1.Deployment) error {
+	t.Helper()
+	const egRestartAnnotation = "gateway.envoyproxy.io/restartedAt"
+	restartTime := time.Now().Format(time.RFC3339)
+	ctx := context.Background()
+	ep := v1alpha1.EnvoyProxy{}
+	if err := c.Get(context.Background(), epNN, &ep); err != nil {
+		return err
+	}
+
+	jsonData := fmt.Sprintf("{\"metadata\": {\"annotations\": {\"gateway.envoyproxy.io/restartedAt\": \"%s\"}}, \"spec\": {\"template\": {\"metadata\": {\"annotations\": {\"gateway.envoyproxy.io/restartedAt\": \"%s\"}}}}}", restartTime, restartTime)
+
+	ep.Spec.Provider.Kubernetes.EnvoyDeployment.Patch = &v1alpha1.KubernetesPatchSpec{
+		Value: v1.JSON{
+			Raw: []byte(jsonData),
+		},
+	}
+
+	if err := c.Update(ctx, &ep); err != nil {
+		return err
+	}
+
+	return wait.PollUntilContextTimeout(ctx, 1*time.Second, timeoutConfig.CreateTimeout, true, func(ctx context.Context) (bool, error) {
+		// wait for replicaset with the same annotation to reach ready status
+		podList := &corev1.PodList{}
+		listOpts := []client.ListOption{
+			client.InNamespace(dp.Namespace),
+			client.MatchingLabelsSelector{Selector: labels.SelectorFromSet(dp.Spec.Selector.MatchLabels)},
+		}
+
+		err := c.List(ctx, podList, listOpts...)
+		if err != nil {
+			return false, err
+		}
+
+		rolled := int32(0)
+		for _, rs := range podList.Items {
+			if rs.Annotations[egRestartAnnotation] == restartTime {
+				rolled++
+			}
+		}
+
+		// all pods are rolled
+		if rolled == int32(len(podList.Items)) && rolled >= *dp.Spec.Replicas {
+			return true, nil
+		}
+
+		return false, nil
+	})
+}
diff --git a/test/e2e/tests/tests.go b/test/e2e/tests/tests.go
index 7343ee0ced3..f5f0657de4d 100644
--- a/test/e2e/tests/tests.go
+++ b/test/e2e/tests/tests.go
@@ -10,4 +10,7 @@ package tests
 
 import "sigs.k8s.io/gateway-api/conformance/utils/suite"
 
-var ConformanceTests []suite.ConformanceTest
+var (
+	ConformanceTests []suite.ConformanceTest
+	UpgradeTests     []suite.ConformanceTest
+)
diff --git a/test/e2e/tests/utils.go b/test/e2e/tests/utils.go
index 181f27113b9..a87c71a78ba 100644
--- a/test/e2e/tests/utils.go
+++ b/test/e2e/tests/utils.go
@@ -8,18 +8,27 @@ package tests
 import (
 	"context"
 	"fmt"
+	"io"
+
 	"testing"
 	"time"
 
+	"fortio.org/fortio/fhttp"
+	"fortio.org/fortio/periodic"
+	flog "fortio.org/log"
+
 	"github.com/google/go-cmp/cmp"
 	"github.com/stretchr/testify/require"
+
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/wait"
+
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	gwv1a2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
+	"sigs.k8s.io/gateway-api/conformance/utils/config"
 
 	egv1a1 "github.com/envoyproxy/gateway/api/v1alpha1"
 )
@@ -122,6 +131,45 @@ func AlmostEquals(actual, expect, offset int) bool {
 	return true
 }
 
+// runs a load test with options described in opts
+// the done channel is used to notify caller of execution result
+// the execution may end due to an external abort or timeout
+func runLoadAndWait(t *testing.T, timeoutConfig config.TimeoutConfig, done chan bool, aborter *periodic.Aborter, reqURL string) {
+	flog.SetLogLevel(flog.Error)
+	opts := fhttp.HTTPRunnerOptions{
+		RunnerOptions: periodic.RunnerOptions{
+			QPS: 5000,
+			// allow some overhead time for setting up workers and tearing down after restart
+			Duration:   timeoutConfig.CreateTimeout + timeoutConfig.CreateTimeout/2,
+			NumThreads: 50,
+			Stop:       aborter,
+			Out:        io.Discard,
+		},
+		HTTPOptions: fhttp.HTTPOptions{
+			URL: reqURL,
+		},
+	}
+
+	res, err := fhttp.RunHTTPTest(&opts)
+	if err != nil {
+		done <- false
+		t.Logf("failed to create load: %v", err)
+	}
+
+	// collect stats
+	okReq := res.RetCodes[200]
+	totalReq := res.DurationHistogram.Count
+	failedReq := totalReq - okReq
+	errorReq := res.ErrorsDurationHistogram.Count
+	timedOut := res.ActualDuration == opts.Duration
+	t.Logf("Load completed after %s with %d requests, %d success, %d failures and %d errors", res.ActualDuration, totalReq, okReq, failedReq, errorReq)
+
+	if okReq == totalReq && errorReq == 0 && !timedOut {
+		done <- true
+	}
+	done <- false
+}
+
 func policyAcceptedByAncestor(ancestors []gwv1a2.PolicyAncestorStatus, controllerName string, ancestorRef gwv1a2.ParentReference) bool {
 	for _, ancestor := range ancestors {
 		if string(ancestor.ControllerName) == controllerName && cmp.Equal(ancestor.AncestorRef, ancestorRef) {
diff --git a/test/e2e/upgrade/eg_upgrade_test.go b/test/e2e/upgrade/eg_upgrade_test.go
index cad06b66073..431ecf01960 100644
--- a/test/e2e/upgrade/eg_upgrade_test.go
+++ b/test/e2e/upgrade/eg_upgrade_test.go
@@ -10,11 +10,14 @@ package upgrade
 
 import (
 	"flag"
+
 	"testing"
 
 	"github.com/stretchr/testify/require"
+
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/config"
+
 	gwapiv1 "sigs.k8s.io/gateway-api/apis/v1"
 	gwapiv1a2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 	"sigs.k8s.io/gateway-api/conformance/utils/flags"
@@ -54,5 +57,6 @@ func TestEGUpgrade(t *testing.T) {
 	})
 
 	cSuite.Setup(t)
-	cSuite.Run(t, []suite.ConformanceTest{tests.EGUpgradeTest})
+	t.Logf("Upgrade: Running tests")
+	cSuite.Run(t, []suite.ConformanceTest{tests.EnvoyShutdownTest, tests.EGUpgradeTest})
 }
diff --git a/tools/make/kube.mk b/tools/make/kube.mk
index f2191e0bc00..a862d9db20a 100644
--- a/tools/make/kube.mk
+++ b/tools/make/kube.mk
@@ -123,13 +123,13 @@ run-e2e: install-e2e-telemetry
 	kubectl apply -f test/config/gatewayclass.yaml
 ifeq ($(E2E_RUN_TEST),)
 	go test -v -tags e2e ./test/e2e --gateway-class=envoy-gateway --debug=true --cleanup-base-resources=false
-	go test -v -tags e2e ./test/e2e/upgrade --gateway-class=envoy-gateway --debug=true --cleanup-base-resources=$(E2E_CLEANUP)
+	go test -v -tags e2e ./test/e2e/upgrade --gateway-class=upgrade --debug=true --cleanup-base-resources=$(E2E_CLEANUP)
 else
 ifeq ($(E2E_RUN_EG_UPGRADE_TESTS),false)
 	go test -v -tags e2e ./test/e2e --gateway-class=envoy-gateway --debug=true --cleanup-base-resources=$(E2E_CLEANUP) \
 		--run-test $(E2E_RUN_TEST)
 else
-	go test -v -tags e2e ./test/e2e/upgrade --gateway-class=envoy-gateway --debug=true --cleanup-base-resources=$(E2E_CLEANUP) \
+	go test -v -tags e2e ./test/e2e/upgrade --gateway-class=upgrade --debug=true --cleanup-base-resources=$(E2E_CLEANUP) \
 		--run-test $(E2E_RUN_TEST)
 endif
 endif