diff --git a/packages/menu/demo/menu.stories.tsx b/packages/menu/demo/menu.stories.tsx
index 76723ddab..df42391c0 100644
--- a/packages/menu/demo/menu.stories.tsx
+++ b/packages/menu/demo/menu.stories.tsx
@@ -63,6 +63,54 @@ export const Controlled: Story = {
   },
   args: {
     isExpanded: false,
+    restoreFocus: true,
+    focusedValue: 'plant-01',
+    selectedItems: [{ value: 'Cherry', type: 'checkbox' }]
+  }
+};
+
+export const ControlledManagedFocus: Story = {
+  render: function Render(args) {
+    const updateArgs = useArgs()[1];
+    const triggerRef = React.useRef<HTMLButtonElement>(null);
+
+    return (
+      <MenuStory
+        {...args}
+        triggerRef={triggerRef}
+        onChange={_args => {
+          // eslint-disable-next-line no-console
+          console.log('onChange:', _args);
+
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+          const { type, isExpanded, ...rest } = _args;
+          const { selectedItems } = rest;
+          const nextArgs: typeof rest & { isExpanded?: boolean } = rest;
+
+          const lastItem = selectedItems?.[selectedItems.length - 1];
+          const isNonCheckboxItem = !selectedItems || lastItem?.type !== 'checkbox';
+
+          if (isExpanded !== undefined && isNonCheckboxItem) {
+            nextArgs.isExpanded = isExpanded;
+          }
+
+          if (!args.restoreFocus && nextArgs.isExpanded === false && triggerRef.current) {
+            triggerRef.current.focus();
+          }
+          updateArgs(nextArgs);
+        }}
+      />
+    );
+  },
+  name: 'Controlled + Managed Focus',
+  argTypes: {
+    defaultFocusedValue: { control: false },
+    defaultExpanded: { control: false },
+    focusedValue: { control: { type: 'text' } }
+  },
+  args: {
+    isExpanded: false,
+    restoreFocus: false,
     focusedValue: 'plant-01',
     selectedItems: [{ value: 'Cherry', type: 'checkbox' }]
   }
diff --git a/packages/menu/demo/stories/MenuStory.tsx b/packages/menu/demo/stories/MenuStory.tsx
index a60b8ecf8..788782ee1 100644
--- a/packages/menu/demo/stories/MenuStory.tsx
+++ b/packages/menu/demo/stories/MenuStory.tsx
@@ -91,60 +91,71 @@ const Component = ({
   const selectedValues = selection.map(item => item.value);
 
   return (
-    <div className="relative">
-      <button className="px-2 py-1" type="button" {...getTriggerProps()}>
-        Produce
-      </button>
-
-      <ul
-        className={classNames('border border-grey-400 border-solid w-32 absolute', {
-          invisible: !isExpanded
-        })}
-        {...getMenuProps()}
-      >
-        {items.map((item: MenuItem) => {
-          if ('items' in item) {
-            return (
-              <li key={item.label} role="none">
-                <b aria-hidden="true" className="block mt-1 ms-1">
-                  {item.label}
-                </b>
-                <hr aria-hidden="true" className="my-1 border-grey-200" {...getSeparatorProps()} />
-                <ul {...getItemGroupProps({ 'aria-label': item.label })}>
-                  {item.items.map(groupItem => (
-                    <Item
-                      key={groupItem.value}
-                      item={{ ...groupItem }}
-                      getItemProps={getItemProps}
-                      focusedValue={focusedValue}
-                      isSelected={selectedValues.includes(groupItem.value)}
+    <div>
+      <div>
+        <div className="relative">
+          <button className="px-2 py-1" type="button" {...getTriggerProps()}>
+            Produce
+          </button>
+
+          <ul
+            className={classNames('bg-white border border-grey-400 border-solid w-32 absolute', {
+              invisible: !isExpanded
+            })}
+            {...getMenuProps()}
+          >
+            {items.map((item: MenuItem) => {
+              if ('items' in item) {
+                return (
+                  <li key={item.label} role="none">
+                    <b aria-hidden="true" className="block mt-1 ms-1">
+                      {item.label}
+                    </b>
+                    <hr
+                      aria-hidden="true"
+                      className="my-1 border-grey-200"
+                      {...getSeparatorProps()}
                     />
-                  ))}
-                </ul>
-              </li>
-            );
-          }
-
-          if ('separator' in item) {
-            return (
-              <li
-                key={item.value}
-                className="my-1 border-0 border-b border-solid border-grey-200"
-                {...getSeparatorProps()}
-              />
-            );
-          }
-
-          return (
-            <Item
-              key={item.value}
-              item={item}
-              focusedValue={focusedValue}
-              getItemProps={getItemProps}
-            />
-          );
-        })}
-      </ul>
+                    <ul {...getItemGroupProps({ 'aria-label': item.label })}>
+                      {item.items.map(groupItem => (
+                        <Item
+                          key={groupItem.value}
+                          item={{ ...groupItem }}
+                          getItemProps={getItemProps}
+                          focusedValue={focusedValue}
+                          isSelected={selectedValues.includes(groupItem.value)}
+                        />
+                      ))}
+                    </ul>
+                  </li>
+                );
+              }
+
+              if ('separator' in item) {
+                return (
+                  <li
+                    key={item.value}
+                    className="my-1 border-0 border-b border-solid border-grey-200"
+                    {...getSeparatorProps()}
+                  />
+                );
+              }
+
+              return (
+                <Item
+                  key={item.value}
+                  item={item}
+                  focusedValue={focusedValue}
+                  getItemProps={getItemProps}
+                />
+              );
+            })}
+          </ul>
+        </div>
+        <div>
+          <button style={{ marginTop: 80 }}>click me</button>
+        </div>
+      </div>
     </div>
   );
 };
@@ -167,16 +178,16 @@ interface IArgs extends MenuContainerProps {
   as: 'hook' | 'container';
 }
 
-export const MenuStory: StoryFn<IArgs> = ({ as, ...props }) => {
-  const triggerRef = useRef<HTMLButtonElement>(null);
+export const MenuStory: StoryFn<IArgs> = ({ as, triggerRef, ...props }) => {
+  const _triggerRef = useRef<HTMLButtonElement>(null);
   const menuRef = useRef<HTMLUListElement>(null);
 
   switch (as) {
     case 'container':
-      return <Container {...props} triggerRef={triggerRef} menuRef={menuRef} />;
+      return <Container {...props} triggerRef={triggerRef || _triggerRef} menuRef={menuRef} />;
 
     case 'hook':
     default:
-      return <Hook {...props} triggerRef={triggerRef} menuRef={menuRef} />;
+      return <Hook {...props} triggerRef={triggerRef || _triggerRef} menuRef={menuRef} />;
   }
 };
diff --git a/packages/menu/src/MenuContainer.tsx b/packages/menu/src/MenuContainer.tsx
index e002548e7..600876d14 100644
--- a/packages/menu/src/MenuContainer.tsx
+++ b/packages/menu/src/MenuContainer.tsx
@@ -29,5 +29,12 @@ MenuContainer.propTypes = {
   defaultExpanded: PropTypes.bool,
   selectedItems: PropTypes.arrayOf(PropTypes.any),
   focusedValue: PropTypes.oneOfType([PropTypes.string]),
-  defaultFocusedValue: PropTypes.oneOfType([PropTypes.string])
+  defaultFocusedValue: PropTypes.oneOfType([PropTypes.string]),
+  restoreFocus: PropTypes.bool
+};
+
+MenuContainer.defaultProps = {
+  defaultExpanded: false,
+  restoreFocus: true,
+  rtl: false
 };
diff --git a/packages/menu/src/types.ts b/packages/menu/src/types.ts
index 201de2e1d..7e70a6570 100644
--- a/packages/menu/src/types.ts
+++ b/packages/menu/src/types.ts
@@ -66,6 +66,8 @@ export interface IUseMenuProps<T = HTMLButtonElement, M = HTMLElement> {
   focusedValue?: string | null;
   /** Determines focused value on menu initialization */
   defaultFocusedValue?: string;
+  /** Returns focus to the trigger when the menu is collapsed */
+  restoreFocus?: boolean;
   /** Sets the selected values in a controlled menu */
   selectedItems?: ISelectedItem[];
   /**
diff --git a/packages/menu/src/useMenu.ts b/packages/menu/src/useMenu.ts
index bd1e170a4..913025554 100644
--- a/packages/menu/src/useMenu.ts
+++ b/packages/menu/src/useMenu.ts
@@ -12,7 +12,6 @@ import React, {
   useEffect,
   useMemo,
   useReducer,
-  useRef,
   useState
 } from 'react';
 import { useSelection } from '@zendeskgarden/container-selection';
@@ -49,6 +48,7 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
   onChange = () => undefined,
   isExpanded,
   defaultExpanded = false,
+  restoreFocus = true,
   selectedItems,
   focusedValue,
   defaultFocusedValue
@@ -94,8 +94,6 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
    */
 
   const [menuVisible, setMenuVisible] = useState<boolean>(false);
-  const focusTriggerRef = useRef<boolean>(false);
-
   const [state, dispatch] = useReducer(stateReducer, {
     focusedValue: focusedValue || defaultFocusedValue,
     isExpanded: isExpanded || defaultExpanded,
@@ -135,6 +133,15 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
 
   // Internal
 
+  const returnFocusToTrigger = useCallback(
+    (skip?: boolean) => {
+      if (!skip && restoreFocus && triggerRef.current) {
+        triggerRef.current.focus();
+      }
+    },
+    [triggerRef, restoreFocus]
+  );
+
   const closeMenu = useCallback(
     (changeType: string) => {
       dispatch({
@@ -281,13 +288,22 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
         }
       });
 
+      // Skip focus return when isExpanded === true
+      returnFocusToTrigger(!controlledIsExpanded);
+
       onChange({
         type: changeType,
         focusedValue: null,
         isExpanded: !controlledIsExpanded
       });
     },
-    [controlledIsExpanded, isFocusedValueControlled, isExpandedControlled, onChange]
+    [
+      isFocusedValueControlled,
+      isExpandedControlled,
+      controlledIsExpanded,
+      returnFocusToTrigger,
+      onChange
+    ]
   );
 
   const handleTriggerKeyDown = useCallback(
@@ -321,6 +337,8 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
           }
         });
 
+        returnFocusToTrigger();
+
         onChange({
           type: changeType,
           focusedValue: defaultFocusedValue || nextFocusedValue,
@@ -328,7 +346,14 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
         });
       }
     },
-    [isExpandedControlled, isFocusedValueControlled, defaultFocusedValue, onChange, values]
+    [
+      values,
+      isFocusedValueControlled,
+      defaultFocusedValue,
+      isExpandedControlled,
+      returnFocusToTrigger,
+      onChange
+    ]
   );
 
   const handleMenuKeyDown = useCallback(
@@ -341,14 +366,13 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
 
         const type = StateChangeTypes[key === KEYS.ESCAPE ? 'MenuKeyDownEscape' : 'MenuKeyDownTab'];
 
-        if (KEYS.ESCAPE === key) {
-          focusTriggerRef.current = true;
-        }
+        // TODO: Investigate why focus goes to body instead of next interactive element on TAB keydown. Meanwhile, returning focus to trigger.
+        returnFocusToTrigger();
 
         closeMenu(type);
       }
     },
-    [closeMenu, focusTriggerRef]
+    [closeMenu, returnFocusToTrigger]
   );
 
   const handleMenuBlur = useCallback(
@@ -356,10 +380,11 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
       const path = event.composedPath();
 
       if (!path.includes(menuRef.current!) && !path.includes(triggerRef.current!)) {
+        returnFocusToTrigger();
         closeMenu(StateChangeTypes.MenuBlur);
       }
     },
-    [closeMenu, menuRef, triggerRef]
+    [closeMenu, menuRef, returnFocusToTrigger, triggerRef]
   );
 
   const handleMenuMouseLeave = useCallback(() => {
@@ -395,6 +420,8 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
         }
       });
 
+      returnFocusToTrigger(isTransitionItem);
+
       onChange({
         type: changeType,
         value: item.value,
@@ -403,10 +430,11 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
       });
     },
     [
+      getSelectedItems,
       state.nestedPathIds,
       isExpandedControlled,
       isSelectedItemsControlled,
-      getSelectedItems,
+      returnFocusToTrigger,
       onChange
     ]
   );
@@ -448,19 +476,13 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
           ...(nextSelection && { selectedItems: nextSelection })
         };
 
-        if (item.href) {
-          if (key === KEYS.SPACE) {
-            event.preventDefault();
+        event.preventDefault();
 
-            triggerLink(event.target as HTMLAnchorElement, environment || window);
-          }
-        } else {
-          event.preventDefault();
+        if (item.href) {
+          triggerLink(event.target as HTMLAnchorElement, environment || window);
         }
 
-        if (!isTransitionItem) {
-          focusTriggerRef.current = true;
-        }
+        returnFocusToTrigger(isTransitionItem);
       } else if (key === KEYS.RIGHT) {
         if (rtl && isPrevious) {
           changeType = StateChangeTypes.MenuItemKeyDownPrevious;
@@ -529,15 +551,15 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
       }
     },
     [
-      rtl,
-      state.nestedPathIds,
+      getSelectedItems,
       isExpandedControlled,
-      isFocusedValueControlled,
       isSelectedItemsControlled,
-      focusTriggerRef,
+      returnFocusToTrigger,
       environment,
+      rtl,
       getNextFocusedValue,
-      getSelectedItems,
+      isFocusedValueControlled,
+      state.nestedPathIds,
       onChange
     ]
   );
@@ -594,12 +616,8 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
   }, [controlledIsExpanded, handleMenuBlur, handleMenuKeyDown, environment]);
 
   /**
-   * Handles focus depending on menu state:
-   * - When opened, focus the menu via `focusedValue`
-   * - When closed, focus the trigger via `triggerRef`
-   *
-   * This effect is intended to prevent focusing the trigger or menu
-   * unless the menu is in the right expansion state.
+   * When the menu is opened, this effect sets focus on the current menu item using `focusedValue`
+   * or on the first menu item.
    */
   useEffect(() => {
     if (state.focusOnOpen && menuVisible && controlledFocusedValue && controlledIsExpanded) {
@@ -614,13 +632,7 @@ export const useMenu = <T extends HTMLElement = HTMLElement, M extends HTMLEleme
 
       ref && ref.focus();
     }
-
-    if (!menuVisible && !controlledIsExpanded && focusTriggerRef.current) {
-      triggerRef?.current?.focus();
-      focusTriggerRef.current = false;
-    }
   }, [
-    focusTriggerRef,
     values,
     menuVisible,
     itemRefs,