diff --git a/recovery_ui/screen_ui.cpp b/recovery_ui/screen_ui.cpp
index 087fc0e..b3ef113 100644
--- a/recovery_ui/screen_ui.cpp
+++ b/recovery_ui/screen_ui.cpp
@@ -941,17 +941,27 @@
                                                 closedir);
   dirent* de;
   std::vector<std::string> intro_frame_names;
-  std::vector<std::string> loop_frame_names;
+  std::vector<std::string> default_loop_frame_names;
+  std::vector<std::string> device_loop_frame_names;
+  // Create string format for device-specific loop animations.
+  std::string deviceformat = android::base::GetProperty("ro.product.product.name", "");
+  deviceformat += "%d%n.png";
 
   while ((de = readdir(dir.get())) != nullptr) {
     int value, num_chars;
     if (sscanf(de->d_name, "intro%d%n.png", &value, &num_chars) == 1) {
       intro_frame_names.emplace_back(de->d_name, num_chars);
     } else if (sscanf(de->d_name, "loop%d%n.png", &value, &num_chars) == 1) {
-      loop_frame_names.emplace_back(de->d_name, num_chars);
+      default_loop_frame_names.emplace_back(de->d_name, num_chars);
+    } else if (sscanf(de->d_name, deviceformat.c_str(), &value, &num_chars) == 1) {
+      device_loop_frame_names.emplace_back(de->d_name, num_chars);
     }
   }
 
+  // Favor device-specific loop frames, if they exist.
+  auto& loop_frame_names =
+      device_loop_frame_names.empty() ? default_loop_frame_names : device_loop_frame_names;
+
   size_t intro_frames = intro_frame_names.size();
   size_t loop_frames = loop_frame_names.size();
 
