diff --git a/pkg/scheduler/framework/plugins/defaultpreemption/default_preemption.go b/pkg/scheduler/framework/plugins/defaultpreemption/default_preemption.go
index f1c58de9389..a255aef74a8 100644
--- a/pkg/scheduler/framework/plugins/defaultpreemption/default_preemption.go
+++ b/pkg/scheduler/framework/plugins/defaultpreemption/default_preemption.go
@@ -135,6 +135,11 @@ func (pl *DefaultPreemption) CandidatesToVictimsMap(candidates []preemption.Cand
 	return m
 }
 
+type potentialVictim struct {
+	podInfo     *framework.PodInfo
+	pdbViolated bool
+}
+
 // SelectVictimsOnNode finds minimum set of pods on the given node that should be preempted in order to make enough room
 // for "pod" to be scheduled.
 func (pl *DefaultPreemption) SelectVictimsOnNode(
@@ -195,7 +200,7 @@ func (pl *DefaultPreemption) SelectVictimsOnNode(
 	// Try to reprieve as many pods as possible. We first try to reprieve the PDB
 	// violating victims and then other non-violating ones. In both cases, we start
 	// from the highest priority victims.
-	violatingVictims, nonViolatingVictims := filterPodsWithPDBViolation(potentialVictims, pdbs)
+	finalVictims := filterPodsWithPDBViolation(potentialVictims, pdbs)
 	reprievePod := func(pi *framework.PodInfo) (bool, error) {
 		if err := addPod(pi); err != nil {
 			return false, err
@@ -212,19 +217,15 @@ func (pl *DefaultPreemption) SelectVictimsOnNode(
 		}
 		return fits, nil
 	}
-	for _, p := range violatingVictims {
-		if fits, err := reprievePod(p); err != nil {
+
+	for _, v := range finalVictims {
+		if fits, err := reprievePod(v.podInfo); err != nil {
 			return nil, 0, framework.AsStatus(err)
-		} else if !fits {
+		} else if !fits && v.pdbViolated {
 			numViolatingVictim++
 		}
 	}
-	// Now we try to reprieve non-violating victims.
-	for _, p := range nonViolatingVictims {
-		if _, err := reprievePod(p); err != nil {
-			return nil, 0, framework.AsStatus(err)
-		}
-	}
+
 	return victims, numViolatingVictim, framework.NewStatus(framework.Success)
 }
 
@@ -287,12 +288,13 @@ func podTerminatingByPreemption(p *v1.Pod) bool {
 // preempted.
 // This function is stable and does not change the order of received pods. So, if it
 // receives a sorted list, grouping will preserve the order of the input list.
-func filterPodsWithPDBViolation(podInfos []*framework.PodInfo, pdbs []*policy.PodDisruptionBudget) (violatingPodInfos, nonViolatingPodInfos []*framework.PodInfo) {
+func filterPodsWithPDBViolation(podInfos []*framework.PodInfo, pdbs []*policy.PodDisruptionBudget) []*potentialVictim {
 	pdbsAllowed := make([]int32, len(pdbs))
 	for i, pdb := range pdbs {
 		pdbsAllowed[i] = pdb.Status.DisruptionsAllowed
 	}
 
+	var potentialVictims []*potentialVictim
 	for _, podInfo := range podInfos {
 		pod := podInfo.Pod
 		pdbForPodIsViolated := false
@@ -326,13 +328,15 @@ func filterPodsWithPDBViolation(podInfos []*framework.PodInfo, pdbs []*policy.Po
 				}
 			}
 		}
+		v := &potentialVictim{
+			podInfo: podInfo,
+		}
 		if pdbForPodIsViolated {
-			violatingPodInfos = append(violatingPodInfos, podInfo)
-		} else {
-			nonViolatingPodInfos = append(nonViolatingPodInfos, podInfo)
+			v.pdbViolated = true
 		}
+		potentialVictims = append(potentialVictims, v)
 	}
-	return violatingPodInfos, nonViolatingPodInfos
+	return potentialVictims
 }
 
 func getPDBLister(informerFactory informers.SharedInformerFactory) policylisters.PodDisruptionBudgetLister {