diff --git a/pkg/reconciler/pipelinerun/resources/pipelinerunresolution.go b/pkg/reconciler/pipelinerun/resources/pipelinerunresolution.go
index b1d7e4050c6..fbc186e591b 100644
--- a/pkg/reconciler/pipelinerun/resources/pipelinerunresolution.go
+++ b/pkg/reconciler/pipelinerun/resources/pipelinerunresolution.go
@@ -289,32 +289,94 @@ func (t ResolvedPipelineTask) isCancelled() bool {
 	}
 }
 
-// isScheduled returns true when the PipelineRunTask itself has a TaskRun
-// or Run associated.
+// isScheduled returns true when the PipelineRunTask itself has any TaskRuns/CustomRuns
+// or a singular TaskRun/CustomRun associated.
 func (t ResolvedPipelineTask) isScheduled() bool {
 	if t.IsCustomTask() {
-		return t.RunObject != nil
+		return t.RunObject != nil || len(t.RunObjects) > 0
 	}
-	return t.TaskRun != nil
+	return t.TaskRun != nil || len(t.TaskRuns) > 0
 }
 
-// isStarted returns true only if the PipelineRunTask itself has a TaskRun or
-// Run associated that has a Succeeded-type condition.
+// isStarted returns true only if the PipelineRunTask itself has any TaskRuns/CustomRuns
+// or a singular TaskRun/CustomRun that has a Succeeded-type condition.
 func (t ResolvedPipelineTask) isStarted() bool {
-	if t.IsCustomTask() {
-		return t.RunObject != nil && t.RunObject.GetStatusCondition().GetCondition(apis.ConditionSucceeded) != nil
+	switch {
+	case t.IsCustomTask() && len(t.RunObjects) > 0:
+		return t.hasRunObjectsStarted()
+	case t.IsCustomTask() && t.RunObject != nil:
+		return t.RunObject.GetStatusCondition().GetCondition(apis.ConditionSucceeded) != nil
+	case len(t.TaskRuns) > 0:
+		return t.hasTaskRunsStarted()
+	case t.TaskRun != nil:
+		return t.TaskRun.Status.GetCondition(apis.ConditionSucceeded) != nil
+	default:
+		return false
 	}
-	return t.TaskRun != nil && t.TaskRun.Status.GetCondition(apis.ConditionSucceeded) != nil
 }
 
-// isConditionStatusFalse returns true when a task has succeeded condition with status set to false
-// it includes task failed after retries are exhausted, cancelled tasks, and time outs
+// hasTaskRunsStarted returns true only if any TaskRun that has a Succeeded-type condition.
+func (t ResolvedPipelineTask) hasTaskRunsStarted() bool {
+	for _, taskRun := range t.TaskRuns {
+		if taskRun.GetStatusCondition().GetCondition(apis.ConditionSucceeded) != nil {
+			return true
+		}
+	}
+	return false
+}
+
+// hasRunObjectsStarted returns true only if any RunObject that has a Succeeded-type condition.
+func (t ResolvedPipelineTask) hasRunObjectsStarted() bool {
+	for _, runObject := range t.RunObjects {
+		if runObject.GetStatusCondition().GetCondition(apis.ConditionSucceeded) != nil {
+			return true
+		}
+	}
+	return false
+}
+
+// isConditionStatusFalse returns true when any tasks or a singular task has succeeded condition with
+// status set to false. it includes task failed after retries are exhausted, cancelled tasks, and timeouts
 func (t ResolvedPipelineTask) isConditionStatusFalse() bool {
 	if t.isStarted() {
-		if t.IsCustomTask() {
+		switch {
+		case t.IsCustomTask() && len(t.RunObjects) > 0:
+			return t.areRunObjectConditionStatusFalse()
+		case t.IsCustomTask() && t.RunObject != nil:
 			return t.RunObject.GetStatusCondition().GetCondition(apis.ConditionSucceeded).IsFalse()
+		case len(t.TaskRuns) > 0:
+			return t.areTaskRunsConditionStatusFalse()
+		case t.TaskRun != nil:
+			return t.TaskRun.Status.GetCondition(apis.ConditionSucceeded).IsFalse()
+		default:
+			return false
+		}
+	}
+	return false
+}
+
+// areTaskRunsConditionStatusFalse returns true when any of the taskRuns have succeeded condition with status set to false
+// it includes task failed after retries are exhausted, cancelled tasks, and timeouts
+func (t ResolvedPipelineTask) areTaskRunsConditionStatusFalse() bool {
+	if t.hasTaskRunsStarted() {
+		for _, taskRun := range t.TaskRuns {
+			if taskRun.GetStatusCondition().GetCondition(apis.ConditionSucceeded).IsFalse() {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// areRunObjectConditionStatusFalse returns true when a RunObject has succeeded condition with status set to false
+// it includes task failed after retries are exhausted, cancelled tasks, and timeouts
+func (t ResolvedPipelineTask) areRunObjectConditionStatusFalse() bool {
+	if t.hasRunObjectsStarted() {
+		for _, runObject := range t.RunObjects {
+			if runObject.GetStatusCondition().GetCondition(apis.ConditionSucceeded).IsFalse() {
+				return true
+			}
 		}
-		return t.TaskRun.Status.GetCondition(apis.ConditionSucceeded).IsFalse()
 	}
 	return false
 }
diff --git a/pkg/reconciler/pipelinerun/resources/pipelinerunresolution_test.go b/pkg/reconciler/pipelinerun/resources/pipelinerunresolution_test.go
index 3571a48910b..9d8ba15ac65 100644
--- a/pkg/reconciler/pipelinerun/resources/pipelinerunresolution_test.go
+++ b/pkg/reconciler/pipelinerun/resources/pipelinerunresolution_test.go
@@ -1639,6 +1639,430 @@ func TestIsFailure(t *testing.T) {
 	}
 }
 
+func TestIsStarted(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		rpt  ResolvedPipelineTask
+		want bool
+	}{{
+		name: "taskrun not started",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+		},
+		want: false,
+	}, {
+		name: "run not started",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			CustomTask:   true,
+		},
+		want: false,
+	}, {
+		name: "taskrun running",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			TaskRun:      makeStarted(trs[0]),
+		},
+		want: true,
+	}, {
+		name: "run running",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			CustomTask:   true,
+			RunObject:    makeCustomRunStarted(customRuns[0]),
+		},
+		want: true,
+	}, {
+		name: "taskrun succeeded",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			TaskRun:      makeSucceeded(trs[0]),
+		},
+		want: true,
+	}, {
+		name: "run succeeded",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			CustomTask:   true,
+			RunObject:    makeCustomRunSucceeded(customRuns[0]),
+		},
+		want: true,
+	}, {
+		name: "taskrun failed",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			TaskRun:      makeFailed(trs[0]),
+		},
+		want: true,
+	}, {
+		name: "run failed",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			CustomTask:   true,
+			RunObject:    makeCustomRunFailed(customRuns[0]),
+		},
+		want: true,
+	}, {
+		name: "matrixed taskruns not started",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+		},
+		want: false,
+	}, {
+		name: "matrixed runs not started",
+		rpt: ResolvedPipelineTask{
+			CustomTask:   true,
+			PipelineTask: matrixedPipelineTask,
+		},
+		want: false,
+	}, {
+		name: "matrixed taskruns running",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+			TaskRuns:     []*v1beta1.TaskRun{makeStarted(trs[0]), makeStarted(trs[1])},
+		},
+		want: true,
+	}, {
+		name: "matrixed runs running",
+		rpt: ResolvedPipelineTask{
+			CustomTask:   true,
+			PipelineTask: matrixedPipelineTask,
+			RunObjects:   []v1beta1.RunObject{makeCustomRunStarted(customRuns[0]), makeCustomRunStarted(customRuns[1])},
+		},
+		want: true,
+	}, {
+		name: "one matrixed taskrun running",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+			TaskRuns:     []*v1beta1.TaskRun{makeStarted(trs[0]), makeSucceeded(trs[1])},
+		},
+		want: true,
+	}, {
+		name: "one matrixed run running",
+		rpt: ResolvedPipelineTask{
+			CustomTask:   true,
+			PipelineTask: matrixedPipelineTask,
+			RunObjects:   []v1beta1.RunObject{makeCustomRunStarted(customRuns[0]), makeCustomRunSucceeded(customRuns[1])},
+		},
+		want: true,
+	}, {
+		name: "matrixed taskruns succeeded",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+			TaskRuns:     []*v1beta1.TaskRun{makeSucceeded(trs[0]), makeSucceeded(trs[1])},
+		},
+		want: true,
+	}, {
+		name: "one matrixed taskrun succeeded",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+			TaskRuns:     []*v1beta1.TaskRun{makeSucceeded(trs[0]), makeStarted(trs[1])},
+		},
+		want: true,
+	}, {
+		name: "one matrixed run succeeded",
+		rpt: ResolvedPipelineTask{
+			CustomTask:   true,
+			PipelineTask: matrixedPipelineTask,
+			RunObjects:   []v1beta1.RunObject{makeCustomRunSucceeded(customRuns[0]), makeCustomRunStarted(customRuns[1])},
+		},
+		want: true,
+	}, {
+		name: "matrixed taskruns failed",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+			TaskRuns:     []*v1beta1.TaskRun{makeFailed(trs[0]), makeFailed(trs[1])},
+		},
+		want: true,
+	}, {
+		name: "matrixed runs failed",
+		rpt: ResolvedPipelineTask{
+			CustomTask:   true,
+			PipelineTask: matrixedPipelineTask,
+			RunObjects:   []v1beta1.RunObject{makeCustomRunFailed(customRuns[0]), makeCustomRunFailed(customRuns[1])},
+		},
+		want: true,
+	}} {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := tc.rpt.isStarted(); got != tc.want {
+				t.Errorf("expected isStarted: %t but got %t", tc.want, got)
+			}
+		})
+	}
+}
+
+func TestIsConditionStatusFalse(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		rpt  ResolvedPipelineTask
+		want bool
+	}{{
+		name: "taskrun not started",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+		},
+		want: false,
+	}, {
+		name: "run not started",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			CustomTask:   true,
+		},
+		want: false,
+	}, {
+		name: "taskrun running",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			TaskRun:      makeStarted(trs[0]),
+		},
+		want: false,
+	}, {
+		name: "run running",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			CustomTask:   true,
+			RunObject:    makeCustomRunStarted(customRuns[0]),
+		},
+		want: false,
+	}, {
+		name: "taskrun succeeded",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			TaskRun:      makeSucceeded(trs[0]),
+		},
+		want: false,
+	}, {
+		name: "run succeeded",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			CustomTask:   true,
+			RunObject:    makeCustomRunSucceeded(customRuns[0]),
+		},
+		want: false,
+	}, {
+		name: "taskrun failed",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			TaskRun:      makeFailed(trs[0]),
+		},
+		want: true,
+	}, {
+		name: "run failed",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			CustomTask:   true,
+			RunObject:    makeCustomRunFailed(customRuns[0]),
+		},
+		want: true,
+	}, {
+		name: "taskrun cancelled",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			TaskRun:      withCancelled(makeFailed(trs[0])),
+		},
+		want: true,
+	}, {
+		name: "taskrun cancelled but not failed",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			TaskRun:      withCancelled(newTaskRun(trs[0])),
+		},
+		want: false,
+	}, {
+		name: "taskrun cancelled for timeout",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			TaskRun:      withCancelledForTimeout(makeFailed(trs[0])),
+		},
+		want: true,
+	}, {
+		name: "customrun cancelled",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			RunObject:    withCustomRunCancelled(makeCustomRunFailed(customRuns[0])),
+			CustomTask:   true,
+		},
+		want: true,
+	}, {
+		name: "customrun cancelled for timeout",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			RunObject:    withCustomRunCancelledForTimeout(makeCustomRunFailed(customRuns[0])),
+			CustomTask:   true,
+		},
+		want: true,
+	}, {
+		name: "customrun cancelled but not failed",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: &v1beta1.PipelineTask{Name: "task"},
+			RunObject:    withCustomRunCancelled(newCustomRun(customRuns[0])),
+			CustomTask:   true,
+		},
+		want: false,
+	}, {
+		name: "matrixed taskruns not started",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+		},
+		want: false,
+	}, {
+		name: "matrixed runs not started",
+		rpt: ResolvedPipelineTask{
+			CustomTask:   true,
+			PipelineTask: matrixedPipelineTask,
+		},
+		want: false,
+	}, {
+		name: "matrixed taskruns running",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+			TaskRuns:     []*v1beta1.TaskRun{makeStarted(trs[0]), makeStarted(trs[1])},
+		},
+		want: false,
+	}, {
+		name: "matrixed runs running",
+		rpt: ResolvedPipelineTask{
+			CustomTask:   true,
+			PipelineTask: matrixedPipelineTask,
+			RunObjects:   []v1beta1.RunObject{makeCustomRunStarted(customRuns[0]), makeCustomRunStarted(customRuns[1])},
+		},
+		want: false,
+	}, {
+		name: "one matrixed taskrun running",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+			TaskRuns:     []*v1beta1.TaskRun{makeStarted(trs[0]), makeSucceeded(trs[1])},
+		},
+		want: false,
+	}, {
+		name: "one matrixed run running",
+		rpt: ResolvedPipelineTask{
+			CustomTask:   true,
+			PipelineTask: matrixedPipelineTask,
+			RunObjects:   []v1beta1.RunObject{makeCustomRunStarted(customRuns[0]), makeCustomRunSucceeded(customRuns[1])},
+		},
+		want: false,
+	}, {
+		name: "matrixed taskruns succeeded",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+			TaskRuns:     []*v1beta1.TaskRun{makeSucceeded(trs[0]), makeSucceeded(trs[1])},
+		},
+		want: false,
+	}, {
+		name: "one matrixed taskrun succeeded",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+			TaskRuns:     []*v1beta1.TaskRun{makeSucceeded(trs[0]), makeStarted(trs[1])},
+		},
+		want: false,
+	}, {
+		name: "one matrixed run succeeded",
+		rpt: ResolvedPipelineTask{
+			CustomTask:   true,
+			PipelineTask: matrixedPipelineTask,
+			RunObjects:   []v1beta1.RunObject{makeCustomRunSucceeded(customRuns[0]), makeCustomRunStarted(customRuns[1])},
+		},
+		want: false,
+	}, {
+		name: "matrixed taskruns failed",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+			TaskRuns:     []*v1beta1.TaskRun{makeFailed(trs[0]), makeFailed(trs[1])},
+		},
+		want: true,
+	}, {
+		name: "matrixed runs failed",
+		rpt: ResolvedPipelineTask{
+			CustomTask:   true,
+			PipelineTask: matrixedPipelineTask,
+			RunObjects:   []v1beta1.RunObject{makeCustomRunFailed(customRuns[0]), makeCustomRunFailed(customRuns[1])},
+		},
+		want: true,
+	}, {
+		name: "one matrixed taskrun failed, one matrixed taskrun running",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+			TaskRuns:     []*v1beta1.TaskRun{makeFailed(trs[0]), makeStarted(trs[1])},
+		},
+		want: true,
+	}, {
+		name: "one matrixed run failed, one matrixed run running",
+		rpt: ResolvedPipelineTask{
+			CustomTask:   true,
+			PipelineTask: matrixedPipelineTask,
+			RunObjects:   []v1beta1.RunObject{makeCustomRunFailed(customRuns[0]), makeCustomRunStarted(customRuns[1])},
+		},
+		want: true,
+	}, {
+		name: "matrixed taskruns cancelled",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+			TaskRuns:     []*v1beta1.TaskRun{withCancelled(makeFailed(trs[0])), withCancelled(makeFailed(trs[1]))},
+		},
+		want: true,
+	}, {
+		name: "matrixed runs cancelled",
+		rpt: ResolvedPipelineTask{
+			CustomTask:   true,
+			PipelineTask: matrixedPipelineTask,
+			RunObjects:   []v1beta1.RunObject{withCustomRunCancelled(makeCustomRunFailed(customRuns[0])), withCustomRunCancelled(makeCustomRunFailed(customRuns[1]))},
+		},
+		want: true,
+	}, {
+		name: "one matrixed taskrun cancelled, one matrixed taskrun running",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+			TaskRuns:     []*v1beta1.TaskRun{withCancelled(makeFailed(trs[0])), makeStarted(trs[1])},
+		},
+		want: true,
+	}, {
+		name: "one matrixed run cancelled, one matrixed run running",
+		rpt: ResolvedPipelineTask{
+			CustomTask:   true,
+			PipelineTask: matrixedPipelineTask,
+			RunObjects:   []v1beta1.RunObject{withCustomRunCancelled(makeCustomRunFailed(customRuns[0])), makeCustomRunStarted(customRuns[1])},
+		},
+		want: true,
+	}, {
+		name: "matrixed taskruns cancelled but not failed",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+			TaskRuns:     []*v1beta1.TaskRun{withCancelled(newTaskRun(trs[0])), withCancelled(newTaskRun(trs[1]))},
+		},
+		want: false,
+	}, {
+		name: "matrixed runs cancelled but not failed",
+		rpt: ResolvedPipelineTask{
+			CustomTask:   true,
+			PipelineTask: matrixedPipelineTask,
+			RunObjects:   []v1beta1.RunObject{withCustomRunCancelled(newCustomRun(customRuns[0])), withCustomRunCancelled(newCustomRun(customRuns[1]))},
+		},
+		want: false,
+	}, {
+		name: "one matrixed taskrun cancelled but not failed",
+		rpt: ResolvedPipelineTask{
+			PipelineTask: matrixedPipelineTask,
+			TaskRuns:     []*v1beta1.TaskRun{withCancelled(newTaskRun(trs[0])), makeStarted(trs[1])},
+		},
+		want: false,
+	}, {
+		name: "one matrixed run cancelled but not failed",
+		rpt: ResolvedPipelineTask{
+			CustomTask:   true,
+			PipelineTask: matrixedPipelineTask,
+			RunObjects:   []v1beta1.RunObject{withCustomRunCancelled(newCustomRun(customRuns[0])), makeCustomRunStarted(customRuns[1])},
+		},
+		want: false,
+	}} {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := tc.rpt.isConditionStatusFalse(); got != tc.want {
+				t.Errorf("expected isConditionStatusFalse: %t but got %t", tc.want, got)
+			}
+		})
+	}
+}
+
 func TestSkipBecauseParentTaskWasSkipped(t *testing.T) {
 	for _, tc := range []struct {
 		name     string
diff --git a/pkg/reconciler/pipelinerun/resources/pipelinerunstate.go b/pkg/reconciler/pipelinerun/resources/pipelinerunstate.go
index 208e473ab3a..2cbc0fb8e9b 100644
--- a/pkg/reconciler/pipelinerun/resources/pipelinerunstate.go
+++ b/pkg/reconciler/pipelinerun/resources/pipelinerunstate.go
@@ -112,9 +112,9 @@ func (state PipelineRunState) ToMap() map[string]*ResolvedPipelineTask {
 // IsBeforeFirstTaskRun returns true if the PipelineRun has not yet started its first TaskRun
 func (state PipelineRunState) IsBeforeFirstTaskRun() bool {
 	for _, t := range state {
-		if t.IsCustomTask() && t.RunObject != nil {
+		if t.IsCustomTask() && (t.RunObject != nil || len(t.RunObjects) > 0) {
 			return false
-		} else if t.TaskRun != nil {
+		} else if t.TaskRun != nil || len(t.TaskRuns) > 0 {
 			return false
 		}
 	}
@@ -132,14 +132,26 @@ func (state PipelineRunState) IsBeforeFirstTaskRun() bool {
 func (state PipelineRunState) AdjustStartTime(unadjustedStartTime *metav1.Time) *metav1.Time {
 	adjustedStartTime := unadjustedStartTime
 	for _, rpt := range state {
-		if rpt.TaskRun == nil {
-			if rpt.RunObject != nil {
-				creationTime := rpt.RunObject.GetObjectMeta().GetCreationTimestamp()
+		switch {
+		case len(rpt.RunObjects) > 0:
+			for _, runObject := range rpt.RunObjects {
+				creationTime := runObject.GetObjectMeta().GetCreationTimestamp()
 				if creationTime.Time.Before(adjustedStartTime.Time) {
 					adjustedStartTime = &creationTime
 				}
 			}
-		} else {
+		case rpt.RunObject != nil:
+			creationTime := rpt.RunObject.GetObjectMeta().GetCreationTimestamp()
+			if creationTime.Time.Before(adjustedStartTime.Time) {
+				adjustedStartTime = &creationTime
+			}
+		case len(rpt.TaskRuns) > 0:
+			for _, taskRun := range rpt.TaskRuns {
+				if taskRun.CreationTimestamp.Time.Before(adjustedStartTime.Time) {
+					adjustedStartTime = &taskRun.CreationTimestamp
+				}
+			}
+		case rpt.TaskRun != nil:
 			if rpt.TaskRun.CreationTimestamp.Time.Before(adjustedStartTime.Time) {
 				adjustedStartTime = &rpt.TaskRun.CreationTimestamp
 			}
diff --git a/pkg/reconciler/pipelinerun/resources/pipelinerunstate_test.go b/pkg/reconciler/pipelinerun/resources/pipelinerunstate_test.go
index ebde2347874..6efefa7e222 100644
--- a/pkg/reconciler/pipelinerun/resources/pipelinerunstate_test.go
+++ b/pkg/reconciler/pipelinerun/resources/pipelinerunstate_test.go
@@ -2114,7 +2114,52 @@ func TestAdjustStartTime(t *testing.T) {
 		// We expect this to adjust to the earlier time.
 		want: baseline.Time.Add(-2 * time.Second),
 	}, {
-		name: "run starts later",
+		name: "multiple taskruns, some earlier",
+		prs: PipelineRunState{{
+			TaskRuns: []*v1beta1.TaskRun{{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:              "blah1",
+					CreationTimestamp: metav1.Time{Time: baseline.Time.Add(-1 * time.Second)},
+				},
+			}, {
+				ObjectMeta: metav1.ObjectMeta{
+					Name:              "blah2",
+					CreationTimestamp: metav1.Time{Time: baseline.Time.Add(-2 * time.Second)},
+				},
+			}, {
+				ObjectMeta: metav1.ObjectMeta{
+					Name:              "blah3",
+					CreationTimestamp: metav1.Time{Time: baseline.Time.Add(2 * time.Second)},
+				},
+			}},
+		}},
+		// We expect this to adjust to the earlier time.
+		want: baseline.Time.Add(-2 * time.Second),
+	}, {
+		name: "multiple CustomRuns, some earlier",
+		prs: PipelineRunState{{
+			RunObjects: []v1beta1.RunObject{
+				&v1beta1.CustomRun{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:              "blah1",
+						CreationTimestamp: metav1.Time{Time: baseline.Time.Add(-1 * time.Second)},
+					},
+				}, &v1beta1.CustomRun{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:              "blah2",
+						CreationTimestamp: metav1.Time{Time: baseline.Time.Add(-2 * time.Second)},
+					},
+				}, &v1beta1.CustomRun{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:              "blah3",
+						CreationTimestamp: metav1.Time{Time: baseline.Time.Add(2 * time.Second)},
+					},
+				}},
+		}},
+		// We expect this to adjust to the earlier time.
+		want: baseline.Time.Add(-2 * time.Second),
+	}, {
+		name: "CustomRun starts later",
 		prs: PipelineRunState{{
 			RunObject: &v1beta1.CustomRun{
 				ObjectMeta: metav1.ObjectMeta{
@@ -2126,7 +2171,7 @@ func TestAdjustStartTime(t *testing.T) {
 		// Stay where you are, you are before the Run.
 		want: baseline.Time,
 	}, {
-		name: "run starts earlier",
+		name: "CustomRun starts earlier",
 		prs: PipelineRunState{{
 			RunObject: &v1beta1.CustomRun{
 				ObjectMeta: metav1.ObjectMeta{