diff --git a/web-common/src/features/canvas/filters/CanvasComparisonPill.svelte b/web-common/src/features/canvas/filters/CanvasComparisonPill.svelte
index cd825836179..405c80881ad 100644
--- a/web-common/src/features/canvas/filters/CanvasComparisonPill.svelte
+++ b/web-common/src/features/canvas/filters/CanvasComparisonPill.svelte
@@ -48,6 +48,7 @@
   $: comparisonOptions = getComparisonOptionsForCanvas(
     selectedTimeRange,
     allowCustomTimeRange,
+    activeTimeZone,
   );
 
   function onSelectComparisonRange(
@@ -101,6 +102,7 @@
       {minTimeGrain}
       maxDate={minDate}
       minDate={maxDate}
+      timeGrain={activeTimeGrain}
       timeComparisonOptionsState={comparisonOptions}
       selectedComparison={selectedComparisonTimeRange}
       showComparison={showTimeComparison}
diff --git a/web-common/src/features/canvas/filters/util.ts b/web-common/src/features/canvas/filters/util.ts
index 58d95c2525f..2c1068d0db3 100644
--- a/web-common/src/features/canvas/filters/util.ts
+++ b/web-common/src/features/canvas/filters/util.ts
@@ -1,17 +1,16 @@
-import {
-  getAvailableComparisonsForTimeRange,
-  getComparisonRange,
-} from "@rilldata/web-common/lib/time/comparisons";
-import { PREVIOUS_COMPLETE_DATE_RANGES } from "@rilldata/web-common/lib/time/config";
+import { getAvailableComparisonsForTimeRange } from "@rilldata/web-common/lib/time/comparisons";
 import {
   TimeComparisonOption,
   TimeRangePreset,
   type DashboardTimeControls,
 } from "@rilldata/web-common/lib/time/types";
+import { getComparisonInterval } from "@rilldata/web-common/lib/time/comparisons";
+import { DateTime, Interval } from "luxon";
 
 export function getComparisonOptionsForCanvas(
   selectedTimeRange: DashboardTimeControls | undefined,
   allowCustomTimeRange: boolean,
+  timezone: string,
 ) {
   if (!selectedTimeRange) {
     return [];
@@ -27,35 +26,42 @@ export function getComparisonOptionsForCanvas(
     allOptions = allOptions.filter((o) => o !== TimeComparisonOption.CUSTOM);
   }
 
-  if (
-    selectedTimeRange?.name &&
-    selectedTimeRange?.name in PREVIOUS_COMPLETE_DATE_RANGES
-  ) {
-    // Previous complete ranges should only have previous period.
-    // Other options dont make sense with our current wording of the comparison ranges.
-    allOptions = [TimeComparisonOption.CONTIGUOUS];
-    if (allowCustomTimeRange) allOptions.push(TimeComparisonOption.CUSTOM);
-  }
-
   const timeComparisonOptions = getAvailableComparisonsForTimeRange(
     allTimeRange.start,
     allTimeRange.end,
     selectedTimeRange.start,
     selectedTimeRange.end,
     allOptions,
+    timezone,
   );
 
-  return timeComparisonOptions.map((co, i) => {
-    const comparisonTimeRange = getComparisonRange(
-      selectedTimeRange.start,
-      selectedTimeRange.end,
-      co,
-    );
-    return {
+  const interval = Interval.fromDateTimes(
+    DateTime.fromJSDate(selectedTimeRange.start, { zone: timezone }),
+    DateTime.fromJSDate(selectedTimeRange.end, { zone: timezone }),
+  );
+
+  if (!interval.isValid) {
+    return [];
+  }
+
+  const options: {
+    name: TimeComparisonOption;
+    key: number;
+    start: Date;
+    end: Date;
+  }[] = [];
+
+  timeComparisonOptions.forEach((co, i) => {
+    const comparisonTimeRange = getComparisonInterval(interval, co, timezone);
+
+    if (!comparisonTimeRange) return;
+    options.push({
       name: co,
       key: i,
-      start: comparisonTimeRange.start,
-      end: comparisonTimeRange.end,
-    };
+      start: comparisonTimeRange.start.toJSDate(),
+      end: comparisonTimeRange.end.toJSDate(),
+    });
   });
+
+  return options;
 }
diff --git a/web-common/src/features/canvas/stores/time-state.ts b/web-common/src/features/canvas/stores/time-state.ts
index 4edb7560523..d1574e6fc9a 100644
--- a/web-common/src/features/canvas/stores/time-state.ts
+++ b/web-common/src/features/canvas/stores/time-state.ts
@@ -25,6 +25,7 @@ import {
 } from "@rilldata/web-common/lib/time/new-grains";
 import { maybeWritable } from "@rilldata/web-common/lib/store-utils";
 import type { TimeManager } from "./time-manager";
+import { getComparisonInterval } from "@rilldata/web-common/lib/time/comparisons";
 
 export type MinMax = {
   min: DateTime<true>;
@@ -427,39 +428,3 @@ const timeGrainToComparisonOptionMap: Record<
   [V1TimeGrain.TIME_GRAIN_YEAR]: TimeComparisonOption.YEAR,
   [V1TimeGrain.TIME_GRAIN_UNSPECIFIED]: TimeComparisonOption.CONTIGUOUS,
 };
-
-function getComparisonInterval(
-  interval: Interval<true> | undefined,
-  comparisonRange: string | undefined,
-  activeTimeZone: string,
-): Interval<true> | undefined {
-  if (!interval || !comparisonRange) return undefined;
-
-  let comparisonInterval: Interval | undefined = undefined;
-
-  const COMPARISON_DURATIONS = {
-    "rill-PP": interval.toDuration(),
-    "rill-PD": { days: 1 },
-    "rill-PW": { weeks: 1 },
-    "rill-PM": { months: 1 },
-    "rill-PQ": { quarter: 1 },
-    "rill-PY": { years: 1 },
-  };
-
-  const duration =
-    COMPARISON_DURATIONS[comparisonRange as keyof typeof COMPARISON_DURATIONS];
-
-  if (duration) {
-    comparisonInterval = Interval.fromDateTimes(
-      interval.start.minus(duration),
-      interval.end.minus(duration),
-    );
-  } else {
-    const normalizedRange = comparisonRange.replace(",", "/");
-    comparisonInterval = Interval.fromISO(normalizedRange).mapEndpoints((dt) =>
-      dt.setZone(activeTimeZone),
-    );
-  }
-
-  return comparisonInterval.isValid ? comparisonInterval : undefined;
-}
diff --git a/web-common/src/features/dashboards/filters/Filters.svelte b/web-common/src/features/dashboards/filters/Filters.svelte
index 9770b7a14c5..2de97610a6e 100644
--- a/web-common/src/features/dashboards/filters/Filters.svelte
+++ b/web-common/src/features/dashboards/filters/Filters.svelte
@@ -300,6 +300,8 @@
           | TimeComparisonOption
           | undefined,
         allTimeRange,
+
+        activeTimeZone,
       );
 
     makeTimeSeriesTimeRangeAndUpdateAppState(range, timeGrain, {
diff --git a/web-common/src/features/dashboards/stores/get-explore-state-from-yaml-config.ts b/web-common/src/features/dashboards/stores/get-explore-state-from-yaml-config.ts
index f0d29c61182..12199fab74e 100644
--- a/web-common/src/features/dashboards/stores/get-explore-state-from-yaml-config.ts
+++ b/web-common/src/features/dashboards/stores/get-explore-state-from-yaml-config.ts
@@ -175,6 +175,7 @@ function getDefaultComparisonTimeRangeName(
     timeRange,
     undefined,
     allTimeRange,
+    timezone,
   );
 
   return comparisonTimeRangeName;
diff --git a/web-common/src/features/dashboards/time-controls/comparison-pill/ComparisonPill.svelte b/web-common/src/features/dashboards/time-controls/comparison-pill/ComparisonPill.svelte
index 3709a0ccdbf..51f1691d42c 100644
--- a/web-common/src/features/dashboards/time-controls/comparison-pill/ComparisonPill.svelte
+++ b/web-common/src/features/dashboards/time-controls/comparison-pill/ComparisonPill.svelte
@@ -115,6 +115,7 @@
       minDate={DateTime.fromJSDate(allTimeRange.start)}
       timeComparisonOptionsState={$timeComparisonOptionsState}
       {minTimeGrain}
+      timeGrain={activeTimeGrain}
       selectedComparison={selectedComparisonTimeRange}
       showComparison={showTimeComparison}
       currentInterval={interval}
diff --git a/web-common/src/features/dashboards/time-controls/super-pill/components/Comparison.svelte b/web-common/src/features/dashboards/time-controls/super-pill/components/Comparison.svelte
index 804e2ad68db..08a409cb84a 100644
--- a/web-common/src/features/dashboards/time-controls/super-pill/components/Comparison.svelte
+++ b/web-common/src/features/dashboards/time-controls/super-pill/components/Comparison.svelte
@@ -1,7 +1,6 @@
 <script lang="ts">
   import * as DropdownMenu from "@rilldata/web-common/components/dropdown-menu/";
   import CaretDownIcon from "@rilldata/web-common/components/icons/CaretDownIcon.svelte";
-  import { getComparisonRange } from "@rilldata/web-common/lib/time/comparisons";
   import { TIME_COMPARISON } from "@rilldata/web-common/lib/time/config";
   import {
     type DashboardTimeControls,
@@ -12,7 +11,7 @@
   import RangeDisplay from "./RangeDisplay.svelte";
   import { V1TimeGrain } from "@rilldata/web-common/runtime-client";
   import { V1TimeGrainToDateTimeUnit } from "@rilldata/web-common/lib/time/new-grains";
-
+  import { getComparisonInterval } from "@rilldata/web-common/lib/time/comparisons";
   type Option = {
     name: TimeComparisonOption;
     key: number;
@@ -36,6 +35,7 @@
   ) => void;
   export let allowCustomTimeRange: boolean = true;
   export let minTimeGrain: V1TimeGrain | undefined;
+  export let timeGrain: V1TimeGrain | undefined;
   export let side: "top" | "right" | "bottom" | "left" = "bottom";
 
   let open = false;
@@ -71,16 +71,20 @@
       currentInterval.start &&
       currentInterval.end
     ) {
-      const comparisonTimeRange = getComparisonRange(
-        currentInterval.start.toJSDate(),
-        currentInterval.end.toJSDate(),
+      const comparisonTimeRange = getComparisonInterval(
+        currentInterval,
         comparisonOption,
+        zone,
       );
 
+      if (!comparisonTimeRange) {
+        return;
+      }
+
       onSelectComparisonRange(
         comparisonOption,
-        comparisonTimeRange.start,
-        comparisonTimeRange.end,
+        comparisonTimeRange.start.toJSDate(),
+        comparisonTimeRange.end.toJSDate(),
       );
     }
   }
@@ -111,7 +115,7 @@
         {:else}
           <b class="line-clamp-1">{label}</b>
           {#if interval?.isValid && showFullRange}
-            <RangeDisplay {interval} timeGrain={selectedComparison?.interval} />
+            <RangeDisplay {interval} {timeGrain} />
           {/if}
         {/if}
       </div>
diff --git a/web-common/src/features/dashboards/time-controls/time-control-store.ts b/web-common/src/features/dashboards/time-controls/time-control-store.ts
index baa93abe8bf..160ed36143b 100644
--- a/web-common/src/features/dashboards/time-controls/time-control-store.ts
+++ b/web-common/src/features/dashboards/time-controls/time-control-store.ts
@@ -18,7 +18,6 @@ import { featureFlags } from "@rilldata/web-common/features/feature-flags.ts";
 import { queryClient } from "@rilldata/web-common/lib/svelte-query/globalQueryClient";
 import {
   getComparionRangeForScrub,
-  getComparisonRange,
   getTimeComparisonParametersForComponent,
 } from "@rilldata/web-common/lib/time/comparisons";
 import { DEFAULT_TIME_RANGES } from "@rilldata/web-common/lib/time/config";
@@ -60,6 +59,8 @@ import { derived, get } from "svelte/store";
 import { memoizeMetricsStore } from "../state-managers/memoize-metrics-store";
 import { parseRillTime } from "../url-state/time-ranges/parser";
 import type { RillTime } from "../url-state/time-ranges/RillTime";
+import { DateTime, Interval } from "luxon";
+import { getComparisonInterval } from "@rilldata/web-common/lib/time/comparisons";
 
 export type TimeRangeState = {
   // Selected ranges with start and end filled based on time range type
@@ -404,6 +405,7 @@ export function calculateComparisonTimeRangePartial(
     allTimeRange,
     timeRangeState.selectedTimeRange,
     currentComparisonTimeRange,
+    selectedTimezone,
   );
 
   let comparisonAdjustedStart: string | undefined = undefined;
@@ -552,6 +554,7 @@ export function getComparisonTimeRange(
   allTimeRange: TimeRange | undefined,
   timeRange: DashboardTimeControls | undefined,
   comparisonTimeRange: DashboardTimeControls | undefined,
+  timezone: string | undefined,
 ) {
   if (!timeRange || !timeRange.name || !allTimeRange) return undefined;
 
@@ -561,6 +564,7 @@ export function getComparisonTimeRange(
       timeRange,
       undefined,
       allTimeRange,
+      timezone,
     );
     const range = getTimeComparisonParametersForComponent(
       comparisonOption,
@@ -568,6 +572,7 @@ export function getComparisonTimeRange(
       allTimeRange.end,
       timeRange.start,
       timeRange.end,
+      timezone || "UTC",
     );
 
     return {
@@ -585,16 +590,29 @@ export function getComparisonTimeRange(
   } else {
     // variable time range of some kind.
     const comparisonOption = comparisonTimeRange.name as TimeComparisonOption;
-    const range = getComparisonRange(
-      timeRange.start,
-      timeRange.end,
-      comparisonOption,
+    const interval = Interval.fromDateTimes(
+      DateTime.fromJSDate(timeRange.start, { zone: timezone }),
+      DateTime.fromJSDate(timeRange.end, { zone: timezone }),
     );
 
-    return {
-      ...range,
-      name: comparisonOption,
-    };
+    if (interval.isValid) {
+      const range = getComparisonInterval(
+        interval,
+        comparisonOption,
+        timezone || "UTC",
+      );
+      return {
+        start: range?.start.toJSDate(),
+        end: range?.end.toJSDate(),
+        name: comparisonOption,
+      };
+    } else {
+      return {
+        start: undefined,
+        end: undefined,
+        name: comparisonOption,
+      };
+    }
   }
 }
 
diff --git a/web-common/src/features/dashboards/time-controls/time-range-store.ts b/web-common/src/features/dashboards/time-controls/time-range-store.ts
index 1c9afc6e5c0..1758c86ba15 100644
--- a/web-common/src/features/dashboards/time-controls/time-range-store.ts
+++ b/web-common/src/features/dashboards/time-controls/time-range-store.ts
@@ -1,7 +1,6 @@
 import type { ExploreState } from "@rilldata/web-common/features/dashboards/stores/explore-state";
 import {
   getAvailableComparisonsForTimeRange,
-  getComparisonRange,
   getTimeComparisonParametersForComponent,
 } from "@rilldata/web-common/lib/time/comparisons";
 import {
@@ -30,6 +29,8 @@ import {
 } from "@rilldata/web-common/runtime-client";
 import type { QueryObserverResult } from "@tanstack/svelte-query";
 import { RillTime } from "../url-state/time-ranges/RillTime";
+import { DateTime, Interval } from "luxon";
+import { getComparisonInterval } from "@rilldata/web-common/lib/time/comparisons";
 
 export type TimeRangeControlsState = {
   latestWindowTimeRanges: Array<TimeRangeOption>;
@@ -165,6 +166,7 @@ export function timeComparisonOptionsSelector([
   ) {
     return [];
   }
+  const timezone = explorer.selectedTimezone;
 
   const allTimeRange = {
     name: TimeRangePreset.ALL_TIME,
@@ -185,13 +187,6 @@ export function timeComparisonOptionsSelector([
         ) ?? [];
       allOptions.push(TimeComparisonOption.CUSTOM);
     }
-  } else if (
-    explorer.selectedTimeRange?.name &&
-    explorer.selectedTimeRange?.name in PREVIOUS_COMPLETE_DATE_RANGES
-  ) {
-    // Previous complete ranges should only have previous period.
-    // Other options dont make sense with our current wording of the comparison ranges.
-    allOptions = [TimeComparisonOption.CONTIGUOUS, TimeComparisonOption.CUSTOM];
   }
 
   const timeComparisonOptions = getAvailableComparisonsForTimeRange(
@@ -200,21 +195,36 @@ export function timeComparisonOptionsSelector([
     selectedTimeRange.start,
     selectedTimeRange.end,
     allOptions,
+    timezone,
   );
 
-  return timeComparisonOptions.map((co, i) => {
-    const comparisonTimeRange = getComparisonRange(
-      selectedTimeRange.start,
-      selectedTimeRange.end,
+  const options: {
+    name: TimeComparisonOption;
+    key: number;
+    start: Date;
+    end: Date;
+  }[] = [];
+
+  timeComparisonOptions.forEach((co, i) => {
+    const interval = Interval.fromDateTimes(
+      DateTime.fromJSDate(selectedTimeRange.start, { zone: timezone }),
+      DateTime.fromJSDate(selectedTimeRange.end, { zone: timezone }),
+    );
+    const comparisonTimeRange = getComparisonInterval(
+      interval as Interval<true>,
       co,
+      timezone,
     );
-    return {
+    if (!comparisonTimeRange) return;
+    options.push({
       name: co,
       key: i,
-      start: comparisonTimeRange.start,
-      end: comparisonTimeRange.end,
-    };
+      start: comparisonTimeRange?.start.toJSDate(),
+      end: comparisonTimeRange?.end.toJSDate(),
+    });
   });
+
+  return options;
 }
 
 export function getValidComparisonOption(
@@ -222,6 +232,7 @@ export function getValidComparisonOption(
   selectedTimeRange: TimeRange,
   prevComparisonOption: TimeComparisonOption | undefined,
   allTimeRange: TimeRange,
+  timezone: string | undefined,
 ): TimeComparisonOption {
   if (!timeRanges?.length) {
     return (
@@ -255,6 +266,7 @@ export function getValidComparisonOption(
     allTimeRange.end,
     selectedTimeRange.start,
     selectedTimeRange.end,
+    timezone ?? "UTC",
   );
   // if currently selected comparison option is in allowed list and is valid select it
   if (existing && existingComparison.isComparisonRangeAvailable) {
diff --git a/web-common/src/features/dashboards/url-state/getDefaultExplorePreset.ts b/web-common/src/features/dashboards/url-state/getDefaultExplorePreset.ts
index d69eac92e95..8fa8e78727b 100644
--- a/web-common/src/features/dashboards/url-state/getDefaultExplorePreset.ts
+++ b/web-common/src/features/dashboards/url-state/getDefaultExplorePreset.ts
@@ -178,6 +178,7 @@ function getDefaultComparisonFields(
       timeRange,
       undefined,
       allTimeRange,
+      defaultExplorePreset.timezone,
     );
   }
 
diff --git a/web-common/src/lib/time/comparisons/index.spec.ts b/web-common/src/lib/time/comparisons/index.spec.ts
index c6a01634b49..82d905d2a72 100644
--- a/web-common/src/lib/time/comparisons/index.spec.ts
+++ b/web-common/src/lib/time/comparisons/index.spec.ts
@@ -1,10 +1,11 @@
 import {
   getAvailableComparisonsForTimeRange,
-  getComparisonRange,
   isComparisonInsideBounds,
 } from ".";
 import { TimeComparisonOption } from "../types";
 import { describe, it, expect } from "vitest";
+import { getComparisonInterval } from "@rilldata/web-common/lib/time/comparisons";
+import { DateTime, Interval } from "luxon";
 
 const contiguousAndCustomComparisonRanges = [
   // contiguous cases
@@ -89,23 +90,28 @@ const periodicComparisonTests = [
   },
 ];
 
-const getComparisonRangeTests = [
+const getComparisonIntervalTests = [
   ...contiguousAndCustomComparisonRanges,
   ...periodicComparisonTests,
 ];
 
-describe("getComparisonRange", () => {
-  getComparisonRangeTests.forEach((test) => {
+describe("getComparisonInterval", () => {
+  getComparisonIntervalTests.forEach((test) => {
     it(test.description, () => {
       const { start, end, comparison } = test.input;
       const { start: expectedStart, end: expectedEnd } = test.output;
-      const { start: actualStart, end: actualEnd } = getComparisonRange(
-        start,
-        end,
+      const interval = Interval.fromDateTimes(
+        DateTime.fromJSDate(start, { zone: "UTC" }),
+        DateTime.fromJSDate(end, { zone: "UTC" }),
+      ) as Interval<true>;
+
+      const comparisonInterval = getComparisonInterval(
+        interval,
         comparison,
+        "UTC",
       );
-      expect(actualStart).toEqual(expectedStart);
-      expect(actualEnd).toEqual(expectedEnd);
+      expect(comparisonInterval?.start.toJSDate()).toEqual(expectedStart);
+      expect(comparisonInterval?.end.toJSDate()).toEqual(expectedEnd);
     });
   });
 });
@@ -139,6 +145,7 @@ describe("isComparisonInsideBounds", () => {
         rangeStart,
         rangeEnd,
         input,
+        "UTC",
       );
       expect(actual).toEqual(output);
     });
@@ -245,6 +252,7 @@ describe("getAvailableComparisonsForTimeRange", () => {
         start,
         end,
         [...(Object.values(TimeComparisonOption) as TimeComparisonOption[])],
+        "UTC",
       );
       expect(actual).toEqual(test.output);
     });
diff --git a/web-common/src/lib/time/comparisons/index.ts b/web-common/src/lib/time/comparisons/index.ts
index bfda6180082..8badd4e4664 100644
--- a/web-common/src/lib/time/comparisons/index.ts
+++ b/web-common/src/lib/time/comparisons/index.ts
@@ -6,7 +6,7 @@ import {
   type V1TimeRange,
 } from "@rilldata/web-common/runtime-client";
 import { DateTime, Duration, Interval } from "luxon";
-import { getTimeWidth, transformDate } from "../transforms";
+import { getTimeWidth } from "../transforms";
 import {
   type RelativeTimeTransformation,
   TimeComparisonOption,
@@ -42,22 +42,6 @@ export function getComparisonTransform(
   }
 }
 
-/** takes a start and end, and performs transformDate accordingly.
- * Contiguous periods (for instance "last 6 hours" or a custom range) is handled
- * a bit differently.
- */
-export function getComparisonRange(
-  start: Date,
-  end: Date,
-  comparison: TimeComparisonOption,
-) {
-  const transform = getComparisonTransform(start, end, comparison);
-  return {
-    start: transformDate(start, [transform]),
-    end: transformDate(end, [transform]),
-  };
-}
-
 /**
  * get the comparison range for a scrub such that
  * it aligns with the scrub start and end.
@@ -96,15 +80,34 @@ export function isComparisonInsideBounds(
   start: Date,
   end: Date,
   comparison: TimeComparisonOption,
+  timeZone: string,
 ) {
+  const interval = Interval.fromDateTimes(
+    DateTime.fromJSDate(start),
+    DateTime.fromJSDate(end),
+  );
+  if (!interval.isValid) {
+    return false;
+  }
+  const maxInterval = Interval.fromDateTimes(
+    DateTime.fromJSDate(boundStart),
+    DateTime.fromJSDate(boundEnd),
+  );
   // compute comparison start and ends.
-  const { start: comparisonStart, end: comparisonEnd } = getComparisonRange(
-    start,
-    end,
+  const comparisonInterval = getComparisonInterval(
+    interval,
     comparison,
+    timeZone,
   );
+
+  if (!comparisonInterval || !comparisonInterval.isValid) {
+    return false;
+  }
   // check if comparison bounds are inside the bounds.
-  return comparisonStart >= boundStart && comparisonEnd <= boundEnd;
+  return (
+    maxInterval.contains(comparisonInterval.start) &&
+    maxInterval.contains(comparisonInterval.end)
+  );
 }
 
 export function isRangeLargerThanDuration(
@@ -132,13 +135,26 @@ function isLastPeriodDuplicate(
   start: Date,
   end: Date,
   comparisonOptions: Array<TimeComparisonOption>,
+  zone: string,
 ) {
-  const lastPeriod = getComparisonRange(
-    start,
-    end,
+  const interval = Interval.fromDateTimes(
+    DateTime.fromJSDate(start, { zone }),
+    DateTime.fromJSDate(end, { zone }),
+  );
+
+  if (!interval.isValid) {
+    return false;
+  }
+  const lastPeriod = getComparisonInterval(
+    interval,
     TimeComparisonOption.CONTIGUOUS,
+    zone,
   );
 
+  if (!lastPeriod || !lastPeriod.isValid) {
+    return false;
+  }
+
   comparisonOptions = comparisonOptions.filter(
     (option) =>
       option !== TimeComparisonOption.CUSTOM &&
@@ -146,14 +162,14 @@ function isLastPeriodDuplicate(
   );
 
   return comparisonOptions.some((option) => {
-    const { start: comparisonStart, end: comparisonEnd } = getComparisonRange(
-      start,
-      end,
-      option,
-    );
+    const periodComparison = getComparisonInterval(interval, option, zone);
+
     return (
-      comparisonStart.getTime() === lastPeriod.start.getTime() &&
-      comparisonEnd.getTime() === lastPeriod.end.getTime()
+      lastPeriod &&
+      lastPeriod.isValid &&
+      periodComparison &&
+      lastPeriod.start.equals(periodComparison?.start) &&
+      lastPeriod.end.equals(periodComparison?.end)
     );
   });
 }
@@ -172,6 +188,7 @@ export function getAvailableComparisonsForTimeRange(
   start: Date,
   end: Date,
   comparisonOptions: TimeComparisonOption[],
+  timezone: string,
 ) {
   let comparisons = comparisonOptions.filter((comparison) => {
     if (comparison === TimeComparisonOption.CUSTOM) {
@@ -186,6 +203,7 @@ export function getAvailableComparisonsForTimeRange(
         end,
         // treat a custom comparison as contiguous.
         comparison,
+        timezone,
       ) &&
       !isRangeLargerThanDuration(
         start,
@@ -195,7 +213,7 @@ export function getAvailableComparisonsForTimeRange(
     );
   });
 
-  if (isLastPeriodDuplicate(start, end, comparisonOptions)) {
+  if (isLastPeriodDuplicate(start, end, comparisonOptions, timezone)) {
     comparisons = comparisons.filter(
       (comparison) => comparison !== TimeComparisonOption.CONTIGUOUS,
     );
@@ -211,6 +229,7 @@ export function getTimeComparisonParametersForComponent(
   boundEnd: Date | null | undefined,
   currentStart: Date | null | undefined,
   currentEnd: Date | null | undefined,
+  timezone: string,
 ) {
   if (
     !comparisonOption ||
@@ -226,20 +245,35 @@ export function getTimeComparisonParametersForComponent(
     };
   }
 
-  const { start, end } = getComparisonRange(
-    currentStart,
-    currentEnd,
+  const interval = Interval.fromDateTimes(
+    DateTime.fromJSDate(currentStart).setZone(timezone),
+    DateTime.fromJSDate(currentEnd).setZone(timezone),
+  );
+
+  if (!interval.isValid) {
+    return {
+      start: undefined,
+      end: undefined,
+      isComparisonRangeAvailable: false,
+    };
+  }
+
+  const comparisonInterval = getComparisonInterval(
+    interval,
     comparisonOption,
+    timezone,
   );
 
   const isComparisonRangeAvailable = isComparisonInsideBounds(
     boundStart,
     boundEnd,
-    start,
-    end,
+    interval.start.toJSDate(),
+    interval.end.toJSDate(),
     comparisonOption,
+    timezone,
   );
-
+  const start = comparisonInterval?.start.toJSDate();
+  const end = comparisonInterval?.end.toJSDate();
   return {
     start,
     end,
@@ -276,3 +310,48 @@ export function getComparisonLabel(comparisonTimeRange: V1TimeRange) {
       return `Last ${humaniseISODuration(comparisonTimeRange.isoOffset ?? comparisonTimeRange.expression ?? "")}`;
   }
 }
+
+export function getComparisonInterval(
+  interval: Interval<true> | undefined,
+  comparisonRange: string | undefined,
+  activeTimeZone: string,
+): Interval<true> | undefined {
+  if (!interval || !comparisonRange) return undefined;
+
+  let comparisonInterval: Interval | undefined = undefined;
+
+  const COMPARISON_DURATIONS = {
+    "rill-PP": interval.toDuration(),
+    "rill-PD": { days: 1 },
+    "rill-PW": { weeks: 1 },
+    "rill-PM": { months: 1 },
+    "rill-PQ": { quarter: 1 },
+    "rill-PY": { years: 1 },
+  };
+
+  const duration =
+    COMPARISON_DURATIONS[comparisonRange as keyof typeof COMPARISON_DURATIONS];
+
+  if (duration) {
+    comparisonInterval = Interval.fromDateTimes(
+      interval.start.minus(duration),
+      interval.end.minus(duration),
+    );
+    // If this didn't work, it's likely because we fell on a boundary case
+    // such as looking at March 31st and subtracting a month
+    // We can fall back to adding the duration to the start date
+    if (!comparisonInterval.isValid) {
+      comparisonInterval = Interval.fromDateTimes(
+        interval.start.minus(duration),
+        interval.start.minus(duration).plus(interval.toDuration()),
+      );
+    }
+  } else {
+    const normalizedRange = comparisonRange.replace(",", "/");
+    comparisonInterval = Interval.fromISO(normalizedRange).mapEndpoints((dt) =>
+      dt.setZone(activeTimeZone),
+    );
+  }
+
+  return comparisonInterval.isValid ? comparisonInterval : undefined;
+}
diff --git a/web-common/src/lib/time/config.ts b/web-common/src/lib/time/config.ts
index 2975942ebf0..f29e88dd006 100644
--- a/web-common/src/lib/time/config.ts
+++ b/web-common/src/lib/time/config.ts
@@ -680,7 +680,8 @@ export const TIME_COMPARISON = {
     description:
       "Compare the current time range to the same time range the month before",
     comparisonType: TimeComparisonOption.MONTH,
-    offsetIso: "P1M",
+    // Setting this to P1M prevents month over month comparisons for 31-day months
+    offsetIso: "P31D",
     rillTimeOffset: "-1M",
   },
   [TimeComparisonOption.QUARTER]: {