diff --git a/pkg/scheduler/objects/queue.go b/pkg/scheduler/objects/queue.go
index 9fac11843..259ee4345 100644
--- a/pkg/scheduler/objects/queue.go
+++ b/pkg/scheduler/objects/queue.go
@@ -662,6 +662,18 @@ func (sq *Queue) UpdateQueueProperties(oldMaxResource *resources.Resource) {
 		sq.sortType = policies.FifoSortPolicy
 		return
 	}
+	// Reset fields derived from properties so removed properties revert to defaults.
+	sq.sortType = policies.FifoSortPolicy
+	sq.prioritySortEnabled = true
+	sq.priorityOffset = 0
+	sq.priorityPolicy = policies.DefaultPriorityPolicy
+	sq.preemptionPolicy = policies.DefaultPreemptionPolicy
+	sq.preemptionDelay = configs.DefaultPreemptionDelay
+	sq.unschedAskBackoff = 0
+	sq.askBackoffDelay = configs.DefaultAskBackOffDelay
+	oldDelay := sq.quotaPreemptionDelay
+	sq.quotaPreemptionDelay = configs.DefaultQuotaPreemptionDelay
+	quotaPreemptionDelaySet := false
 	if !sq.isLeaf {
 		// set the sorting type for parent queues
 		sq.sortType = policies.FairSortPolicy
@@ -727,13 +739,12 @@ func (sq *Queue) UpdateQueueProperties(oldMaxResource *resources.Resource) {
 					zap.Error(err))
 			}
 		case configs.QuotaPreemptionDelay:
-			oldDelay := sq.quotaPreemptionDelay
+			quotaPreemptionDelaySet = true
 			sq.quotaPreemptionDelay, err = convertDelay(value, configs.DefaultQuotaPreemptionDelay)
 			if err != nil {
 				log.Log(log.SchedQueue).Debug("quota preemption delay configuration error",
 					zap.Error(err))
 			}
-			sq.setPreemptionTime(oldMaxResource, oldDelay)
 		default:
 			// skip unknown properties just log them
 			log.Log(log.SchedQueue).Debug("queue property skipped",
@@ -741,6 +752,13 @@ func (sq *Queue) UpdateQueueProperties(oldMaxResource *resources.Resource) {
 				zap.String("value", value))
 		}
 	}
+	if quotaPreemptionDelaySet || oldDelay != sq.quotaPreemptionDelay {
+		if sq.quotaPreemptionDelay == 0 {
+			sq.quotaPreemptionStartTime = time.Time{}
+			return
+		}
+		sq.setPreemptionTime(oldMaxResource, oldDelay)
+	}
 }
 
 // GetQueuePath returns the fully qualified path of this queue.
diff --git a/pkg/scheduler/objects/queue_test.go b/pkg/scheduler/objects/queue_test.go
index 4718ae293..a2eecbe7f 100644
--- a/pkg/scheduler/objects/queue_test.go
+++ b/pkg/scheduler/objects/queue_test.go
@@ -3263,6 +3263,48 @@ func TestQueueBackoffProperties(t *testing.T) {
 	assert.Equal(t, 30*time.Second, leaf3.GetBackoffDelay())
 }
 
+func TestUpdateQueuePropertiesReset(t *testing.T) {
+	root, err := createRootQueue(nil)
+	assert.NilError(t, err, "failed to create basic root queue")
+
+	leaf, err := createManagedQueue(root, "leaf", false, nil)
+	assert.NilError(t, err, "failed to create managed queue")
+
+	leaf.properties = map[string]string{
+		configs.ApplicationSortPolicy:                    policies.FairSortPolicy.String(),
+		configs.ApplicationSortPriority:                  configs.ApplicationSortPriorityDisabled,
+		configs.PriorityOffset:                           "5",
+		configs.PriorityPolicy:                           policies.FencePriorityPolicy.String(),
+		configs.PreemptionDelay:                          "10s",
+		configs.PreemptionPolicy:                         policies.FencePreemptionPolicy.String(),
+		configs.ApplicationUnschedulableAsksBackoff:      "12",
+		configs.ApplicationUnschedulableAsksBackoffDelay: "20s",
+		configs.QuotaPreemptionDelay:                     "1m",
+	}
+	leaf.UpdateQueueProperties(nil)
+	assert.Equal(t, leaf.sortType, policies.FairSortPolicy)
+	assert.Equal(t, leaf.prioritySortEnabled, false)
+	assert.Equal(t, leaf.priorityOffset, int32(5))
+	assert.Equal(t, leaf.priorityPolicy, policies.FencePriorityPolicy)
+	assert.Equal(t, leaf.preemptionDelay, 10*time.Second)
+	assert.Equal(t, leaf.preemptionPolicy, policies.FencePreemptionPolicy)
+	assert.Equal(t, leaf.unschedAskBackoff, uint64(12))
+	assert.Equal(t, leaf.askBackoffDelay, 20*time.Second)
+	assert.Equal(t, leaf.quotaPreemptionDelay, time.Minute)
+
+	leaf.properties = map[string]string{}
+	leaf.UpdateQueueProperties(nil)
+	assert.Equal(t, leaf.sortType, policies.FifoSortPolicy)
+	assert.Equal(t, leaf.prioritySortEnabled, true)
+	assert.Equal(t, leaf.priorityOffset, int32(0))
+	assert.Equal(t, leaf.priorityPolicy, policies.DefaultPriorityPolicy)
+	assert.Equal(t, leaf.preemptionDelay, configs.DefaultPreemptionDelay)
+	assert.Equal(t, leaf.preemptionPolicy, policies.DefaultPreemptionPolicy)
+	assert.Equal(t, leaf.unschedAskBackoff, uint64(0))
+	assert.Equal(t, leaf.askBackoffDelay, configs.DefaultAskBackOffDelay)
+	assert.Equal(t, leaf.quotaPreemptionDelay, configs.DefaultQuotaPreemptionDelay)
+}
+
 func TestQueue_setPreemptionTime(t *testing.T) {
 	root, e := createRootQueue(nil)
 	assert.NilError(t, e, "failed to create basic root queue")