diff --git a/stan/math/prim/prob.hpp b/stan/math/prim/prob.hpp
index 664f97c6897..dda31cc1803 100644
--- a/stan/math/prim/prob.hpp
+++ b/stan/math/prim/prob.hpp
@@ -311,11 +311,11 @@
 #include <stan/math/prim/prob/weibull_rng.hpp>
 #include <stan/math/prim/prob/wiener5_lpdf.hpp>
 #include <stan/math/prim/prob/wiener_lpdf.hpp>
-#include <stan/math/prim/prob/wiener4_lcdf.hpp>
-#include <stan/math/prim/prob/wiener4_lccdf.hpp>
+#include <stan/math/prim/prob/wiener4_lcdf_defective.hpp>
+#include <stan/math/prim/prob/wiener4_lccdf_defective.hpp>
 #include <stan/math/prim/prob/wiener_full_lpdf.hpp>
-#include <stan/math/prim/prob/wiener_full_lcdf.hpp>
-#include <stan/math/prim/prob/wiener_full_lccdf.hpp>
+#include <stan/math/prim/prob/wiener_full_lcdf_defective.hpp>
+#include <stan/math/prim/prob/wiener_full_lccdf_defective.hpp>
 #include <stan/math/prim/prob/wishart_cholesky_lpdf.hpp>
 #include <stan/math/prim/prob/wishart_cholesky_rng.hpp>
 #include <stan/math/prim/prob/wishart_lpdf.hpp>
diff --git a/stan/math/prim/prob/wiener4_lccdf.hpp b/stan/math/prim/prob/wiener4_lccdf_defective.hpp
similarity index 97%
rename from stan/math/prim/prob/wiener4_lccdf.hpp
rename to stan/math/prim/prob/wiener4_lccdf_defective.hpp
index d8ca88bd8b8..dd907a8bc00 100644
--- a/stan/math/prim/prob/wiener4_lccdf.hpp
+++ b/stan/math/prim/prob/wiener4_lccdf_defective.hpp
@@ -1,7 +1,7 @@
-#ifndef STAN_MATH_PRIM_PROB_WIENER4_LCCDF_HPP
-#define STAN_MATH_PRIM_PROB_WIENER4_LCCDF_HPP
+#ifndef STAN_MATH_PRIM_PROB_WIENER4_LCCDF_DEFECTIVE_HPP
+#define STAN_MATH_PRIM_PROB_WIENER4_LCCDF_DEFECTIVE_HPP
 
-#include <stan/math/prim/prob/wiener4_lcdf.hpp>
+#include <stan/math/prim/prob/wiener4_lcdf_defective.hpp>
 
 namespace stan {
 namespace math {
@@ -224,9 +224,9 @@ inline auto wiener4_ccdf_grad_w(const T_y& y, const T_a& a, const T_v& v,
  */
 template <bool propto = false, typename T_y, typename T_a, typename T_t0,
           typename T_w, typename T_v>
-inline auto wiener_lccdf(const T_y& y, const T_a& a, const T_t0& t0,
-                         const T_w& w, const T_v& v,
-                         const double& precision_derivatives) {
+inline auto wiener_lccdf_defective(const T_y& y, const T_a& a, const T_t0& t0,
+                                   const T_w& w, const T_v& v,
+                                   const double& precision_derivatives) {
   using T_partials_return = partials_return_t<T_y, T_a, T_t0, T_w, T_v>;
   using ret_t = return_type_t<T_y, T_a, T_t0, T_w, T_v>;
   using T_y_ref = ref_type_if_t<!is_constant<T_y>::value, T_y>;
diff --git a/stan/math/prim/prob/wiener4_lcdf.hpp b/stan/math/prim/prob/wiener4_lcdf_defective.hpp
similarity index 98%
rename from stan/math/prim/prob/wiener4_lcdf.hpp
rename to stan/math/prim/prob/wiener4_lcdf_defective.hpp
index b80824fa16b..150f05bfd36 100644
--- a/stan/math/prim/prob/wiener4_lcdf.hpp
+++ b/stan/math/prim/prob/wiener4_lcdf_defective.hpp
@@ -1,5 +1,5 @@
-#ifndef STAN_MATH_PRIM_PROB_WIENER4_LCDF_HPP
-#define STAN_MATH_PRIM_PROB_WIENER4_LCDF_HPP
+#ifndef STAN_MATH_PRIM_PROB_WIENER4_LCDF_DEFECTIVE_HPP
+#define STAN_MATH_PRIM_PROB_WIENER4_LCDF_DEFECTIVE_HPP
 
 #include <stan/math/prim/prob/wiener5_lpdf.hpp>
 
@@ -586,9 +586,9 @@ inline auto wiener4_cdf_grad_w(const T_y& y, const T_a& a, const T_v& v,
  */
 template <bool propto = false, typename T_y, typename T_a, typename T_t0,
           typename T_w, typename T_v>
-inline auto wiener_lcdf(const T_y& y, const T_a& a, const T_t0& t0,
-                        const T_w& w, const T_v& v,
-                        const double& precision_derivatives = 1e-4) {
+inline auto wiener_lcdf_defective(const T_y& y, const T_a& a, const T_t0& t0,
+                                  const T_w& w, const T_v& v,
+                                  const double& precision_derivatives = 1e-4) {
   using T_partials_return = partials_return_t<T_y, T_a, T_t0, T_w, T_v>;
   using T_y_ref = ref_type_if_t<!is_constant<T_y>::value, T_y>;
   using T_a_ref = ref_type_if_t<!is_constant<T_a>::value, T_a>;
diff --git a/stan/math/prim/prob/wiener_full_lccdf.hpp b/stan/math/prim/prob/wiener_full_lccdf_defective.hpp
similarity index 95%
rename from stan/math/prim/prob/wiener_full_lccdf.hpp
rename to stan/math/prim/prob/wiener_full_lccdf_defective.hpp
index c5cf883c886..747f072c08b 100644
--- a/stan/math/prim/prob/wiener_full_lccdf.hpp
+++ b/stan/math/prim/prob/wiener_full_lccdf_defective.hpp
@@ -1,8 +1,8 @@
-#ifndef STAN_MATH_PRIM_PROB_WIENER_FULL_LCCDF_HPP
-#define STAN_MATH_PRIM_PROB_WIENER_FULL_LCCDF_HPP
+#ifndef STAN_MATH_PRIM_PROB_WIENER_FULL_LCCDF_DEFECTIVE_HPP
+#define STAN_MATH_PRIM_PROB_WIENER_FULL_LCCDF_DEFECTIVE_HPP
 
-#include <stan/math/prim/prob/wiener4_lccdf.hpp>
-#include <stan/math/prim/prob/wiener_full_lcdf.hpp>
+#include <stan/math/prim/prob/wiener4_lccdf_defective.hpp>
+#include <stan/math/prim/prob/wiener_full_lcdf_defective.hpp>
 
 namespace stan {
 namespace math {
@@ -84,10 +84,10 @@ inline auto wiener7_ccdf_grad_sw(const T_y& y, const T_a& a, const T_v& v,
 template <bool propto = false, typename T_y, typename T_a, typename T_t0,
           typename T_w, typename T_v, typename T_sv, typename T_sw,
           typename T_st0>
-inline auto wiener_lccdf(const T_y& y, const T_a& a, const T_t0& t0,
-                         const T_w& w, const T_v& v, const T_sv& sv,
-                         const T_sw& sw, const T_st0& st0,
-                         const double& precision_derivatives = 1e-8) {
+inline auto wiener_lccdf_defective(const T_y& y, const T_a& a, const T_t0& t0,
+                                   const T_w& w, const T_v& v, const T_sv& sv,
+                                   const T_sw& sw, const T_st0& st0,
+                                   const double& precision_derivatives = 1e-8) {
   using ret_t = return_type_t<T_y, T_a, T_t0, T_w, T_v, T_sv, T_sw, T_st0>;
   using T_y_ref = ref_type_if_t<!is_constant<T_y>::value, T_y>;
   using T_a_ref = ref_type_if_t<!is_constant<T_a>::value, T_a>;
@@ -124,7 +124,7 @@ inline auto wiener_lccdf(const T_y& y, const T_a& a, const T_t0& t0,
     return ret_t(0.0);
   }
 
-  static constexpr const char* function_name = "wiener_lccdf";
+  static constexpr const char* function_name = "wiener_lccdf_defective";
   check_consistent_sizes(function_name, "Random variable", y,
                          "Boundary separation", a, "Drift rate", v,
                          "A-priori bias", w, "Nondecision time", t0,
@@ -211,8 +211,9 @@ inline auto wiener_lccdf(const T_y& y, const T_a& a, const T_t0& t0,
   // calculate density and partials
   for (size_t i = 0; i < N; i++) {
     if (sv_vec[i] == 0 && sw_vec[i] == 0 && st0_vec[i] == 0) {
-      result += wiener_lccdf<propto>(y_vec[i], a_vec[i], t0_vec[i], w_vec[i],
-                                     v_vec[i], precision_derivatives);
+      result += wiener_lccdf_defective<propto>(y_vec[i], a_vec[i], t0_vec[i],
+                                               w_vec[i], v_vec[i],
+                                               precision_derivatives);
       continue;
     }
     const T_partials_return y_value = y_vec.val(i);
diff --git a/stan/math/prim/prob/wiener_full_lcdf.hpp b/stan/math/prim/prob/wiener_full_lcdf_defective.hpp
similarity index 97%
rename from stan/math/prim/prob/wiener_full_lcdf.hpp
rename to stan/math/prim/prob/wiener_full_lcdf_defective.hpp
index 2a659ad4c0f..a75a0200021 100644
--- a/stan/math/prim/prob/wiener_full_lcdf.hpp
+++ b/stan/math/prim/prob/wiener_full_lcdf_defective.hpp
@@ -1,7 +1,7 @@
-#ifndef STAN_MATH_PRIM_PROB_WIENER_FULL_LCDF_HPP
-#define STAN_MATH_PRIM_PROB_WIENER_FULL_LCDF_HPP
+#ifndef STAN_MATH_PRIM_PROB_WIENER_FULL_LCDF_DEFECTIVE_HPP
+#define STAN_MATH_PRIM_PROB_WIENER_FULL_LCDF_DEFECTIVE_HPP
 
-#include <stan/math/prim/prob/wiener4_lcdf.hpp>
+#include <stan/math/prim/prob/wiener4_lcdf_defective.hpp>
 #include <stan/math/prim/prob/wiener_full_lpdf.hpp>
 
 namespace stan {
@@ -260,10 +260,10 @@ inline auto wiener7_integrate_cdf(const Wiener7FunctorT& wiener7_functor,
 template <bool propto = false, typename T_y, typename T_a, typename T_t0,
           typename T_w, typename T_v, typename T_sv, typename T_sw,
           typename T_st0>
-inline auto wiener_lcdf(const T_y& y, const T_a& a, const T_t0& t0,
-                        const T_w& w, const T_v& v, const T_sv& sv,
-                        const T_sw& sw, const T_st0& st0,
-                        const double& precision_derivatives = 1e-8) {
+inline auto wiener_lcdf_defective(const T_y& y, const T_a& a, const T_t0& t0,
+                                  const T_w& w, const T_v& v, const T_sv& sv,
+                                  const T_sw& sw, const T_st0& st0,
+                                  const double& precision_derivatives = 1e-8) {
   using ret_t = return_type_t<T_y, T_a, T_t0, T_w, T_v, T_sv, T_sw, T_st0>;
   using T_y_ref = ref_type_if_t<!is_constant<T_y>::value, T_y>;
   using T_a_ref = ref_type_if_t<!is_constant<T_a>::value, T_a>;
@@ -300,7 +300,7 @@ inline auto wiener_lcdf(const T_y& y, const T_a& a, const T_t0& t0,
     return ret_t(0);
   }
 
-  static constexpr const char* function_name = "wiener_lcdf";
+  static constexpr const char* function_name = "wiener_lcdf_defective";
   check_consistent_sizes(function_name, "Random variable", y,
                          "Boundary separation", a, "Drift rate", v,
                          "A-priori bias", w, "Nondecision time", t0,
@@ -387,8 +387,9 @@ inline auto wiener_lcdf(const T_y& y, const T_a& a, const T_t0& t0,
   // calculate density and partials
   for (size_t i = 0; i < N; i++) {
     if (sv_vec[i] == 0 && sw_vec[i] == 0 && st0_vec[i] == 0) {
-      result += wiener_lcdf<propto>(y_vec[i], a_vec[i], t0_vec[i], w_vec[i],
-                                    v_vec[i], precision_derivatives);
+      result += wiener_lcdf_defective<propto>(y_vec[i], a_vec[i], t0_vec[i],
+                                              w_vec[i], v_vec[i],
+                                              precision_derivatives);
       continue;
     }
     const T_partials_return y_value = y_vec.val(i);
diff --git a/test/unit/math/mix/prob/wiener4_lccdf_0_test.cpp b/test/unit/math/mix/prob/wiener4_lccdf_defective_0_test.cpp
similarity index 75%
rename from test/unit/math/mix/prob/wiener4_lccdf_0_test.cpp
rename to test/unit/math/mix/prob/wiener4_lccdf_defective_0_test.cpp
index d32b38c7fa6..016da6d274a 100644
--- a/test/unit/math/mix/prob/wiener4_lccdf_0_test.cpp
+++ b/test/unit/math/mix/prob/wiener4_lccdf_defective_0_test.cpp
@@ -7,7 +7,7 @@ TEST(mathMixDouble, wiener4_lccdf) {
   double t0 = 0.2;
   double w = 0.5;
   double v = 1.5;
-  stan::math::wiener_lccdf(y, a, t0, w, v, 1e-4);
+  stan::math::wiener_lccdf_defective(y, a, t0, w, v, 1e-4);
 }
 
 TEST(mathMixVar, wiener4_lccdf) {
@@ -17,7 +17,7 @@ TEST(mathMixVar, wiener4_lccdf) {
   var t0 = 0.2;
   var w = 0.5;
   var v = 1.5;
-  stan::math::wiener_lccdf(y, a, t0, w, v, 1e-4);
+  stan::math::wiener_lccdf_defective(y, a, t0, w, v, 1e-4);
 }
 
 TEST(mathMixFVar, wiener4_lccdf) {
@@ -29,5 +29,5 @@ TEST(mathMixFVar, wiener4_lccdf) {
   fvar<var> w = 0.5;
   fvar<var> v = 1.5;
   double error = 1e-4;
-  stan::math::wiener_lccdf(y, a, t0, w, v, error);
+  stan::math::wiener_lccdf_defective(y, a, t0, w, v, error);
 }
diff --git a/test/unit/math/mix/prob/wiener4_lcdf_1_test.cpp b/test/unit/math/mix/prob/wiener4_lccdf_defective_1_test.cpp
similarity index 62%
rename from test/unit/math/mix/prob/wiener4_lcdf_1_test.cpp
rename to test/unit/math/mix/prob/wiener4_lccdf_defective_1_test.cpp
index 2cda5b5899c..6f75372c701 100644
--- a/test/unit/math/mix/prob/wiener4_lcdf_1_test.cpp
+++ b/test/unit/math/mix/prob/wiener4_lccdf_defective_1_test.cpp
@@ -2,46 +2,46 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST_F(Wiener4MixArgs, wiener_lcdf_y_a_t0) {
+TEST_F(Wiener4MixArgs, wiener_lccdf_defective_y_a_t0) {
   auto f_y_a_t0 = [](const auto& w, const auto& v) {
     return [&w, &v](const auto& y, const auto& a, const auto& t0) {
-      return stan::math::wiener_lcdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_y_a_t0(w, v), y, a, t0);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lcdf_y_a_w) {
+TEST_F(Wiener4MixArgs, wiener_lccdf_defective_y_a_w) {
   auto f_y_a_w = [](const auto& t0, const auto& v) {
     return [&t0, &v](const auto& y, const auto& a, const auto& w) {
-      return stan::math::wiener_lcdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_y_a_w(t0, v), y, a, w);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lcdf_y_a_v) {
+TEST_F(Wiener4MixArgs, wiener_lccdf_defective_y_a_v) {
   auto f_y_a_v = [](const auto& t0, const auto& w) {
     return [&t0, &w](const auto& y, const auto& a, const auto& v) {
-      return stan::math::wiener_lcdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_y_a_v(t0, w), y, a, v);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lcdf_y_t0_w) {
+TEST_F(Wiener4MixArgs, wiener_lccdf_defective_y_t0_w) {
   auto f_y_t0_w = [](const auto& a, const auto& v) {
     return [&a, &v](const auto& y, const auto& t0, const auto& w) {
-      return stan::math::wiener_lcdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_y_t0_w(a, v), y, t0, w);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lcdf_y_t0_v) {
+TEST_F(Wiener4MixArgs, wiener_lccdf_defective_y_t0_v) {
   auto f_y_t0_v = [](const auto& a, const auto& w) {
     return [&a, &w](const auto& y, const auto& t0, const auto& v) {
-      return stan::math::wiener_lcdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_y_t0_v(a, w), y, t0, v);
diff --git a/test/unit/math/mix/prob/wiener4_lcdf_2_test.cpp b/test/unit/math/mix/prob/wiener4_lccdf_defective_2_test.cpp
similarity index 62%
rename from test/unit/math/mix/prob/wiener4_lcdf_2_test.cpp
rename to test/unit/math/mix/prob/wiener4_lccdf_defective_2_test.cpp
index 2677da3b92b..0b905a7673a 100644
--- a/test/unit/math/mix/prob/wiener4_lcdf_2_test.cpp
+++ b/test/unit/math/mix/prob/wiener4_lccdf_defective_2_test.cpp
@@ -2,46 +2,46 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST_F(Wiener4MixArgs, wiener_lcdf_y_w_v) {
+TEST_F(Wiener4MixArgs, wiener_lccdf_defective_y_w_v) {
   auto f_y_w_v = [](const auto& a, const auto& t0) {
     return [&a, &t0](const auto& y, const auto& w, const auto& v) {
-      return stan::math::wiener_lcdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_y_w_v(a, t0), y, w, v);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lcdf_a_t0_w) {
+TEST_F(Wiener4MixArgs, wiener_lccdf_defective_a_t0_w) {
   auto f_a_t0_w = [](const auto& y, const auto& v) {
     return [&y, &v](const auto& a, const auto& t0, const auto& w) {
-      return stan::math::wiener_lcdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_a_t0_w(y, v), a, t0, w);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lcdf_a_t0_v) {
+TEST_F(Wiener4MixArgs, wiener_lccdf_defective_a_t0_v) {
   auto f_a_t0_v = [](const auto& y, const auto& w) {
     return [&y, &w](const auto& a, const auto& t0, const auto& v) {
-      return stan::math::wiener_lcdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_a_t0_v(y, w), a, t0, v);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lcdf_a_w_v) {
+TEST_F(Wiener4MixArgs, wiener_lccdf_defective_a_w_v) {
   auto f_a_w_v = [](const auto& y, const auto& t0) {
     return [&y, &t0](const auto& a, const auto& w, const auto& v) {
-      return stan::math::wiener_lcdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_a_w_v(y, t0), a, w, v);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lcdf_t0_w_v) {
+TEST_F(Wiener4MixArgs, wiener_lccdf_defective_t0_w_v) {
   auto f_t0_w_v = [](const auto& y, const auto& a) {
     return [&y, &a](const auto& t0, const auto& w, const auto& v) {
-      return stan::math::wiener_lcdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_t0_w_v(y, a), t0, w, v);
diff --git a/test/unit/math/mix/prob/wiener4_lcdf_0_test.cpp b/test/unit/math/mix/prob/wiener4_lcdf_defective_0_test.cpp
similarity index 75%
rename from test/unit/math/mix/prob/wiener4_lcdf_0_test.cpp
rename to test/unit/math/mix/prob/wiener4_lcdf_defective_0_test.cpp
index 23a7d5d3ae1..3ad74e6c9f6 100644
--- a/test/unit/math/mix/prob/wiener4_lcdf_0_test.cpp
+++ b/test/unit/math/mix/prob/wiener4_lcdf_defective_0_test.cpp
@@ -7,7 +7,7 @@ TEST(mathMixDouble, wiener4_lcdf) {
   double t0 = 0.2;
   double w = 0.5;
   double v = 1.5;
-  stan::math::wiener_lcdf(y, a, t0, w, v, 1e-4);
+  stan::math::wiener_lcdf_defective(y, a, t0, w, v, 1e-4);
 }
 
 TEST(mathMixVar, wiener4_lcdf) {
@@ -17,7 +17,7 @@ TEST(mathMixVar, wiener4_lcdf) {
   var t0 = 0.2;
   var w = 0.5;
   var v = 1.5;
-  stan::math::wiener_lcdf(y, a, t0, w, v, 1e-4);
+  stan::math::wiener_lcdf_defective(y, a, t0, w, v, 1e-4);
 }
 
 TEST(mathMixFVar, wiener4_lcdf) {
@@ -29,5 +29,5 @@ TEST(mathMixFVar, wiener4_lcdf) {
   fvar<var> w = 0.5;
   fvar<var> v = 1.5;
   double error = 1e-4;
-  stan::math::wiener_lcdf(y, a, t0, w, v, error);
+  stan::math::wiener_lcdf_defective(y, a, t0, w, v, error);
 }
diff --git a/test/unit/math/mix/prob/wiener4_lccdf_1_test.cpp b/test/unit/math/mix/prob/wiener4_lcdf_defective_1_test.cpp
similarity index 62%
rename from test/unit/math/mix/prob/wiener4_lccdf_1_test.cpp
rename to test/unit/math/mix/prob/wiener4_lcdf_defective_1_test.cpp
index 26425508337..d7a9c280d30 100644
--- a/test/unit/math/mix/prob/wiener4_lccdf_1_test.cpp
+++ b/test/unit/math/mix/prob/wiener4_lcdf_defective_1_test.cpp
@@ -2,46 +2,46 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST_F(Wiener4MixArgs, wiener_lccdf_y_a_t0) {
+TEST_F(Wiener4MixArgs, wiener_lcdf_defective_y_a_t0) {
   auto f_y_a_t0 = [](const auto& w, const auto& v) {
     return [&w, &v](const auto& y, const auto& a, const auto& t0) {
-      return stan::math::wiener_lccdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lcdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_y_a_t0(w, v), y, a, t0);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lccdf_y_a_w) {
+TEST_F(Wiener4MixArgs, wiener_lcdf_defective_y_a_w) {
   auto f_y_a_w = [](const auto& t0, const auto& v) {
     return [&t0, &v](const auto& y, const auto& a, const auto& w) {
-      return stan::math::wiener_lccdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lcdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_y_a_w(t0, v), y, a, w);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lccdf_y_a_v) {
+TEST_F(Wiener4MixArgs, wiener_lcdf_defective_y_a_v) {
   auto f_y_a_v = [](const auto& t0, const auto& w) {
     return [&t0, &w](const auto& y, const auto& a, const auto& v) {
-      return stan::math::wiener_lccdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lcdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_y_a_v(t0, w), y, a, v);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lccdf_y_t0_w) {
+TEST_F(Wiener4MixArgs, wiener_lcdf_defective_y_t0_w) {
   auto f_y_t0_w = [](const auto& a, const auto& v) {
     return [&a, &v](const auto& y, const auto& t0, const auto& w) {
-      return stan::math::wiener_lccdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lcdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_y_t0_w(a, v), y, t0, w);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lccdf_y_t0_v) {
+TEST_F(Wiener4MixArgs, wiener_lcdf_defective_y_t0_v) {
   auto f_y_t0_v = [](const auto& a, const auto& w) {
     return [&a, &w](const auto& y, const auto& t0, const auto& v) {
-      return stan::math::wiener_lccdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lcdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_y_t0_v(a, w), y, t0, v);
diff --git a/test/unit/math/mix/prob/wiener4_lccdf_2_test.cpp b/test/unit/math/mix/prob/wiener4_lcdf_defective_2_test.cpp
similarity index 62%
rename from test/unit/math/mix/prob/wiener4_lccdf_2_test.cpp
rename to test/unit/math/mix/prob/wiener4_lcdf_defective_2_test.cpp
index 579bf94189a..0001f8d1f4f 100644
--- a/test/unit/math/mix/prob/wiener4_lccdf_2_test.cpp
+++ b/test/unit/math/mix/prob/wiener4_lcdf_defective_2_test.cpp
@@ -2,46 +2,46 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST_F(Wiener4MixArgs, wiener_lccdf_y_w_v) {
+TEST_F(Wiener4MixArgs, wiener_lcdf_defective_y_w_v) {
   auto f_y_w_v = [](const auto& a, const auto& t0) {
     return [&a, &t0](const auto& y, const auto& w, const auto& v) {
-      return stan::math::wiener_lccdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lcdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_y_w_v(a, t0), y, w, v);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lccdf_a_t0_w) {
+TEST_F(Wiener4MixArgs, wiener_lcdf_defective_a_t0_w) {
   auto f_a_t0_w = [](const auto& y, const auto& v) {
     return [&y, &v](const auto& a, const auto& t0, const auto& w) {
-      return stan::math::wiener_lccdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lcdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_a_t0_w(y, v), a, t0, w);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lccdf_a_t0_v) {
+TEST_F(Wiener4MixArgs, wiener_lcdf_defective_a_t0_v) {
   auto f_a_t0_v = [](const auto& y, const auto& w) {
     return [&y, &w](const auto& a, const auto& t0, const auto& v) {
-      return stan::math::wiener_lccdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lcdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_a_t0_v(y, w), a, t0, v);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lccdf_a_w_v) {
+TEST_F(Wiener4MixArgs, wiener_lcdf_defective_a_w_v) {
   auto f_a_w_v = [](const auto& y, const auto& t0) {
     return [&y, &t0](const auto& a, const auto& w, const auto& v) {
-      return stan::math::wiener_lccdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lcdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_a_w_v(y, t0), a, w, v);
 }
 
-TEST_F(Wiener4MixArgs, wiener_lccdf_t0_w_v) {
+TEST_F(Wiener4MixArgs, wiener_lcdf_defective_t0_w_v) {
   auto f_t0_w_v = [](const auto& y, const auto& a) {
     return [&y, &a](const auto& t0, const auto& w, const auto& v) {
-      return stan::math::wiener_lccdf(y, a, t0, w, v, 1e-4);
+      return stan::math::wiener_lcdf_defective(y, a, t0, w, v, 1e-4);
     };
   };
   stan::test::expect_ad(f_t0_w_v(y, a), t0, w, v);
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_11_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_11_test.cpp
deleted file mode 100644
index 11d7d7c5c27..00000000000
--- a/test/unit/math/mix/prob/wiener_full_lccdf_11_test.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stan/math/mix.hpp>
-#include <test/unit/math/test_ad.hpp>
-#include <test/unit/math/mix/prob/util.hpp>
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_w_sw_st0) {
-  auto f_w_sw_st0 = [](const auto& y, const auto& a, const auto& t0,
-                       const auto& v, const auto& sv) {
-    return
-        [&y, &a, &t0, &v, &sv](const auto& w, const auto& sw, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_w_sw_st0(y, a, t0, v, sv), w, sw, st0);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_v_sv_sw) {
-  auto f_v_sv_sw = [](const auto& y, const auto& a, const auto& t0,
-                      const auto& w, const auto& st0) {
-    return
-        [&y, &a, &t0, &w, &st0](const auto& v, const auto& sv, const auto& sw) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_v_sv_sw(y, a, t0, w, st0), v, sv, sw);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_v_sv_st0) {
-  auto f_v_sv_st0 = [](const auto& y, const auto& a, const auto& t0,
-                       const auto& w, const auto& sw) {
-    return
-        [&y, &a, &t0, &w, &sw](const auto& v, const auto& sv, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_v_sv_st0(y, a, t0, w, sw), v, sv, st0);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_v_sw_st0) {
-  auto f_v_sw_st0 = [](const auto& y, const auto& a, const auto& t0,
-                       const auto& w, const auto& sv) {
-    return
-        [&y, &a, &t0, &w, &sv](const auto& v, const auto& sw, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_v_sw_st0(y, a, t0, w, sv), v, sw, st0);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_sv_sw_st0) {
-  auto f_sv_sw_st0 = [](const auto& y, const auto& a, const auto& t0,
-                        const auto& w, const auto& v) {
-    return
-        [&y, &a, &t0, &w, &v](const auto& sv, const auto& sw, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_sv_sw_st0(y, a, t0, w, v), sv, sw, st0);
-}
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_1_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_1_test.cpp
deleted file mode 100644
index 771e20d4c57..00000000000
--- a/test/unit/math/mix/prob/wiener_full_lccdf_1_test.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stan/math/mix.hpp>
-#include <test/unit/math/test_ad.hpp>
-#include <test/unit/math/mix/prob/util.hpp>
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_a_w) {
-  auto f_y_a_w = [](const auto& t0, const auto& v, const auto& sv,
-                    const auto& sw, const auto& st0) {
-    return
-        [&t0, &v, &sv, &sw, &st0](const auto& y, const auto& a, const auto& w) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_a_w(t0, v, sv, sw, st0), y, a, w);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_a_v) {
-  auto f_y_a_v = [](const auto& t0, const auto& w, const auto& sv,
-                    const auto& sw, const auto& st0) {
-    return
-        [&t0, &w, &sv, &sw, &st0](const auto& y, const auto& a, const auto& v) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_a_v(t0, w, sv, sw, st0), y, a, v);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_a_sv) {
-  auto f_y_a_sv = [](const auto& t0, const auto& w, const auto& v,
-                     const auto& sw, const auto& st0) {
-    return
-        [&t0, &w, &v, &sw, &st0](const auto& y, const auto& a, const auto& sv) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_a_sv(t0, w, v, sw, st0), y, a, sv);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_a_sw) {
-  auto f_y_a_sw = [](const auto& t0, const auto& w, const auto& v,
-                     const auto& sv, const auto& st0) {
-    return
-        [&t0, &w, &v, &sv, &st0](const auto& y, const auto& a, const auto& sw) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_a_sw(t0, w, v, sv, st0), y, a, sw);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_a_st0) {
-  auto f_y_a_st0 = [](const auto& t0, const auto& w, const auto& v,
-                      const auto& sv, const auto& sw) {
-    return
-        [&t0, &w, &v, &sv, &sw](const auto& y, const auto& a, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_a_st0(t0, w, v, sv, sw), y, a, st0);
-}
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_3_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_3_test.cpp
deleted file mode 100644
index 870d294bfc0..00000000000
--- a/test/unit/math/mix/prob/wiener_full_lccdf_3_test.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stan/math/mix.hpp>
-#include <test/unit/math/test_ad.hpp>
-#include <test/unit/math/mix/prob/util.hpp>
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_w_v) {
-  auto f_y_w_v = [](const auto& a, const auto& t0, const auto& sv,
-                    const auto& sw, const auto& st0) {
-    return
-        [&a, &t0, &sv, &sw, &st0](const auto& y, const auto& w, const auto& v) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_w_v(a, t0, sv, sw, st0), y, w, v);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_w_sv) {
-  auto f_y_w_sv = [](const auto& a, const auto& t0, const auto& v,
-                     const auto& sw, const auto& st0) {
-    return
-        [&a, &t0, &v, &sw, &st0](const auto& y, const auto& w, const auto& sv) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_w_sv(a, t0, v, sw, st0), y, w, sv);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_w_sw) {
-  auto f_y_w_sw = [](const auto& a, const auto& t0, const auto& v,
-                     const auto& sv, const auto& st0) {
-    return
-        [&a, &t0, &v, &sv, &st0](const auto& y, const auto& w, const auto& sw) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_w_sw(a, t0, v, sv, st0), y, w, sw);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_w_st0) {
-  auto f_y_w_st0 = [](const auto& a, const auto& t0, const auto& v,
-                      const auto& sv, const auto& sw) {
-    return
-        [&a, &t0, &v, &sv, &sw](const auto& y, const auto& w, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_w_st0(a, t0, v, sv, sw), y, w, st0);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_v_sv) {
-  auto f_y_v_sv = [](const auto& a, const auto& t0, const auto& w,
-                     const auto& sw, const auto& st0) {
-    return
-        [&a, &t0, &w, &sw, &st0](const auto& y, const auto& v, const auto& sv) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_v_sv(a, t0, w, sw, st0), y, v, sv);
-}
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_4_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_4_test.cpp
deleted file mode 100644
index 8277f69f45b..00000000000
--- a/test/unit/math/mix/prob/wiener_full_lccdf_4_test.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stan/math/mix.hpp>
-#include <test/unit/math/test_ad.hpp>
-#include <test/unit/math/mix/prob/util.hpp>
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_v_sw) {
-  auto f_y_v_sw = [](const auto& a, const auto& t0, const auto& w,
-                     const auto& sv, const auto& st0) {
-    return
-        [&a, &t0, &w, &sv, &st0](const auto& y, const auto& v, const auto& sw) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_v_sw(a, t0, w, sv, st0), y, v, sw);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_v_st0) {
-  auto f_y_v_st0 = [](const auto& a, const auto& t0, const auto& w,
-                      const auto& sv, const auto& sw) {
-    return
-        [&a, &t0, &w, &sv, &sw](const auto& y, const auto& v, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_v_st0(a, t0, w, sv, sw), y, v, st0);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_sv_sw) {
-  auto f_y_sv_sw = [](const auto& a, const auto& t0, const auto& w,
-                      const auto& v, const auto& st0) {
-    return
-        [&a, &t0, &w, &v, &st0](const auto& y, const auto& sv, const auto& sw) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_sv_sw(a, t0, w, v, st0), y, sv, sw);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_sv_st0) {
-  auto f_y_sv_st0 = [](const auto& a, const auto& t0, const auto& w,
-                       const auto& v, const auto& sw) {
-    return
-        [&a, &t0, &w, &v, &sw](const auto& y, const auto& sv, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_sv_st0(a, t0, w, v, sw), y, sv, st0);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_sw_st0) {
-  auto f_y_sw_st0 = [](const auto& a, const auto& t0, const auto& w,
-                       const auto& v, const auto& sv) {
-    return
-        [&a, &t0, &w, &v, &sv](const auto& y, const auto& sw, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_sw_st0(a, t0, w, v, sv), y, sw, st0);
-}
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_8_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_8_test.cpp
deleted file mode 100644
index 39128239a62..00000000000
--- a/test/unit/math/mix/prob/wiener_full_lccdf_8_test.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stan/math/mix.hpp>
-#include <test/unit/math/test_ad.hpp>
-#include <test/unit/math/mix/prob/util.hpp>
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_t0_w_v) {
-  auto f_t0_w_v = [](const auto& y, const auto& a, const auto& sv,
-                     const auto& sw, const auto& st0) {
-    return
-        [&y, &a, &sv, &sw, &st0](const auto& t0, const auto& w, const auto& v) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_t0_w_v(y, a, sv, sw, st0), t0, w, v);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_t0_w_sv) {
-  auto f_t0_w_sv = [](const auto& y, const auto& a, const auto& v,
-                      const auto& sw, const auto& st0) {
-    return
-        [&y, &a, &v, &sw, &st0](const auto& t0, const auto& w, const auto& sv) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_t0_w_sv(y, a, v, sw, st0), t0, w, sv);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_t0_w_sw) {
-  auto f_t0_w_sw = [](const auto& y, const auto& a, const auto& v,
-                      const auto& sv, const auto& st0) {
-    return
-        [&y, &a, &v, &sv, &st0](const auto& t0, const auto& w, const auto& sw) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_t0_w_sw(y, a, v, sv, st0), t0, w, sw);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_t0_w_st0) {
-  auto f_t0_w_st0 = [](const auto& y, const auto& a, const auto& v,
-                       const auto& sv, const auto& sw) {
-    return
-        [&y, &a, &v, &sv, &sw](const auto& t0, const auto& w, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_t0_w_st0(y, a, v, sv, sw), t0, w, st0);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lccdf_t0_v_sv) {
-  auto f_t0_v_sv = [](const auto& y, const auto& a, const auto& w,
-                      const auto& sw, const auto& st0) {
-    return
-        [&y, &a, &w, &sw, &st0](const auto& t0, const auto& v, const auto& sv) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_t0_v_sv(y, a, w, sw, st0), t0, v, sv);
-}
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_0_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_defective_0_test.cpp
similarity index 58%
rename from test/unit/math/mix/prob/wiener_full_lccdf_0_test.cpp
rename to test/unit/math/mix/prob/wiener_full_lccdf_defective_0_test.cpp
index 569c677d043..83af709844c 100644
--- a/test/unit/math/mix/prob/wiener_full_lccdf_0_test.cpp
+++ b/test/unit/math/mix/prob/wiener_full_lccdf_defective_0_test.cpp
@@ -2,7 +2,7 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST(mathMixDouble, wiener_lccdf) {
+TEST(mathMixDouble, wiener_lccdf_defective) {
   double y = 1.0;
   double a = 2.0;
   double t0 = 0.2;
@@ -11,10 +11,10 @@ TEST(mathMixDouble, wiener_lccdf) {
   double sv = 0.2;
   double sw = 0.2;
   double st0 = 0.2;
-  stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0, 1e-4);
+  stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0, 1e-4);
 }
 
-TEST(mathMixVar, wiener_lccdf) {
+TEST(mathMixVar, wiener_lccdf_defective) {
   using stan::math::var;
   var y = 1.0;
   var a = 2.0;
@@ -24,10 +24,10 @@ TEST(mathMixVar, wiener_lccdf) {
   var sv = 0.2;
   var sw = 0;
   var st0 = 0.2;
-  stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+  stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
 }
 
-TEST(mathMixFVar, wiener_lccdf) {
+TEST(mathMixFVar, wiener_lccdf_defective) {
   using stan::math::fvar;
   using stan::math::var;
   fvar<var> y = 1.0;
@@ -38,16 +38,16 @@ TEST(mathMixFVar, wiener_lccdf) {
   fvar<var> sv = 0.2;
   fvar<var> sw = 0;
   fvar<var> st0 = 0.2;
-  stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+  stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_a_t0) {
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_a_t0) {
   auto f_y_a_t0 = [](const auto& w, const auto& v, const auto& sv,
                      const auto& sw, const auto& st0) {
-    return
-        [&w, &v, &sv, &sw, &st0](const auto& y, const auto& a, const auto& t0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
-        };
+    return [&w, &v, &sv, &sw, &st0](const auto& y, const auto& a,
+                                    const auto& t0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
   };
   stan::test::expect_ad(f_y_a_t0(w, v, sv, sw, st0), y, a, t0);
 }
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_defective_10_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_defective_10_test.cpp
new file mode 100644
index 00000000000..dacbbe2815b
--- /dev/null
+++ b/test/unit/math/mix/prob/wiener_full_lccdf_defective_10_test.cpp
@@ -0,0 +1,58 @@
+#include <stan/math/mix.hpp>
+#include <test/unit/math/test_ad.hpp>
+#include <test/unit/math/mix/prob/util.hpp>
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_w_v_sv) {
+  auto f_w_v_sv = [](const auto& y, const auto& a, const auto& t0,
+                     const auto& sw, const auto& st0) {
+    return [&y, &a, &t0, &sw, &st0](const auto& w, const auto& v,
+                                    const auto& sv) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_w_v_sv(y, a, t0, sw, st0), w, v, sv);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_w_v_sw) {
+  auto f_w_v_sw = [](const auto& y, const auto& a, const auto& t0,
+                     const auto& sv, const auto& st0) {
+    return [&y, &a, &t0, &sv, &st0](const auto& w, const auto& v,
+                                    const auto& sw) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_w_v_sw(y, a, t0, sv, st0), w, v, sw);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_w_v_st0) {
+  auto f_w_v_st0 = [](const auto& y, const auto& a, const auto& t0,
+                      const auto& sv, const auto& sw) {
+    return [&y, &a, &t0, &sv, &sw](const auto& w, const auto& v,
+                                   const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_w_v_st0(y, a, t0, sv, sw), w, v, st0);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_w_sv_sw) {
+  auto f_w_sv_sw = [](const auto& y, const auto& a, const auto& t0,
+                      const auto& v, const auto& st0) {
+    return [&y, &a, &t0, &v, &st0](const auto& w, const auto& sv,
+                                   const auto& sw) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_w_sv_sw(y, a, t0, v, st0), w, sv, sw);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_w_sv_st0) {
+  auto f_w_sv_st0 = [](const auto& y, const auto& a, const auto& t0,
+                       const auto& v, const auto& sw) {
+    return [&y, &a, &t0, &v, &sw](const auto& w, const auto& sv,
+                                  const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_w_sv_st0(y, a, t0, v, sw), w, sv, st0);
+}
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_defective_11_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_defective_11_test.cpp
new file mode 100644
index 00000000000..bc07c45b236
--- /dev/null
+++ b/test/unit/math/mix/prob/wiener_full_lccdf_defective_11_test.cpp
@@ -0,0 +1,58 @@
+#include <stan/math/mix.hpp>
+#include <test/unit/math/test_ad.hpp>
+#include <test/unit/math/mix/prob/util.hpp>
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_w_sw_st0) {
+  auto f_w_sw_st0 = [](const auto& y, const auto& a, const auto& t0,
+                       const auto& v, const auto& sv) {
+    return [&y, &a, &t0, &v, &sv](const auto& w, const auto& sw,
+                                  const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_w_sw_st0(y, a, t0, v, sv), w, sw, st0);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_v_sv_sw) {
+  auto f_v_sv_sw = [](const auto& y, const auto& a, const auto& t0,
+                      const auto& w, const auto& st0) {
+    return [&y, &a, &t0, &w, &st0](const auto& v, const auto& sv,
+                                   const auto& sw) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_v_sv_sw(y, a, t0, w, st0), v, sv, sw);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_v_sv_st0) {
+  auto f_v_sv_st0 = [](const auto& y, const auto& a, const auto& t0,
+                       const auto& w, const auto& sw) {
+    return [&y, &a, &t0, &w, &sw](const auto& v, const auto& sv,
+                                  const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_v_sv_st0(y, a, t0, w, sw), v, sv, st0);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_v_sw_st0) {
+  auto f_v_sw_st0 = [](const auto& y, const auto& a, const auto& t0,
+                       const auto& w, const auto& sv) {
+    return [&y, &a, &t0, &w, &sv](const auto& v, const auto& sw,
+                                  const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_v_sw_st0(y, a, t0, w, sv), v, sw, st0);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_sv_sw_st0) {
+  auto f_sv_sw_st0 = [](const auto& y, const auto& a, const auto& t0,
+                        const auto& w, const auto& v) {
+    return [&y, &a, &t0, &w, &v](const auto& sv, const auto& sw,
+                                 const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_sv_sw_st0(y, a, t0, w, v), sv, sw, st0);
+}
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_defective_1_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_defective_1_test.cpp
new file mode 100644
index 00000000000..201ade2e33d
--- /dev/null
+++ b/test/unit/math/mix/prob/wiener_full_lccdf_defective_1_test.cpp
@@ -0,0 +1,58 @@
+#include <stan/math/mix.hpp>
+#include <test/unit/math/test_ad.hpp>
+#include <test/unit/math/mix/prob/util.hpp>
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_a_w) {
+  auto f_y_a_w = [](const auto& t0, const auto& v, const auto& sv,
+                    const auto& sw, const auto& st0) {
+    return [&t0, &v, &sv, &sw, &st0](const auto& y, const auto& a,
+                                     const auto& w) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_a_w(t0, v, sv, sw, st0), y, a, w);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_a_v) {
+  auto f_y_a_v = [](const auto& t0, const auto& w, const auto& sv,
+                    const auto& sw, const auto& st0) {
+    return [&t0, &w, &sv, &sw, &st0](const auto& y, const auto& a,
+                                     const auto& v) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_a_v(t0, w, sv, sw, st0), y, a, v);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_a_sv) {
+  auto f_y_a_sv = [](const auto& t0, const auto& w, const auto& v,
+                     const auto& sw, const auto& st0) {
+    return [&t0, &w, &v, &sw, &st0](const auto& y, const auto& a,
+                                    const auto& sv) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_a_sv(t0, w, v, sw, st0), y, a, sv);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_a_sw) {
+  auto f_y_a_sw = [](const auto& t0, const auto& w, const auto& v,
+                     const auto& sv, const auto& st0) {
+    return [&t0, &w, &v, &sv, &st0](const auto& y, const auto& a,
+                                    const auto& sw) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_a_sw(t0, w, v, sv, st0), y, a, sw);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_a_st0) {
+  auto f_y_a_st0 = [](const auto& t0, const auto& w, const auto& v,
+                      const auto& sv, const auto& sw) {
+    return [&t0, &w, &v, &sv, &sw](const auto& y, const auto& a,
+                                   const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_a_st0(t0, w, v, sv, sw), y, a, st0);
+}
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_defective_2_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_defective_2_test.cpp
new file mode 100644
index 00000000000..4fcd257465d
--- /dev/null
+++ b/test/unit/math/mix/prob/wiener_full_lccdf_defective_2_test.cpp
@@ -0,0 +1,58 @@
+#include <stan/math/mix.hpp>
+#include <test/unit/math/test_ad.hpp>
+#include <test/unit/math/mix/prob/util.hpp>
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_t0_w) {
+  auto f_y_t0_w = [](const auto& a, const auto& v, const auto& sv,
+                     const auto& sw, const auto& st0) {
+    return [&a, &v, &sv, &sw, &st0](const auto& y, const auto& t0,
+                                    const auto& w) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_t0_w(a, v, sv, sw, st0), y, t0, w);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_t0_v) {
+  auto f_y_t0_v = [](const auto& a, const auto& w, const auto& sv,
+                     const auto& sw, const auto& st0) {
+    return [&a, &w, &sv, &sw, &st0](const auto& y, const auto& t0,
+                                    const auto& v) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_t0_v(a, w, sv, sw, st0), y, t0, v);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_t0_sv) {
+  auto f_y_t0_sv = [](const auto& a, const auto& w, const auto& v,
+                      const auto& sw, const auto& st0) {
+    return [&a, &w, &v, &sw, &st0](const auto& y, const auto& t0,
+                                   const auto& sv) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_t0_sv(a, w, v, sw, st0), y, t0, sv);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_t0_sw) {
+  auto f_y_t0_sw = [](const auto& a, const auto& w, const auto& v,
+                      const auto& sv, const auto& st0) {
+    return [&a, &w, &v, &sv, &st0](const auto& y, const auto& t0,
+                                   const auto& sw) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_t0_sw(a, w, v, sv, st0), y, t0, sw);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_t0_st0) {
+  auto f_y_t0_st0 = [](const auto& a, const auto& w, const auto& v,
+                       const auto& sv, const auto& sw) {
+    return [&a, &w, &v, &sv, &sw](const auto& y, const auto& t0,
+                                  const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_t0_st0(a, w, v, sv, sw), y, t0, st0);
+}
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_defective_3_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_defective_3_test.cpp
new file mode 100644
index 00000000000..71a370d59bc
--- /dev/null
+++ b/test/unit/math/mix/prob/wiener_full_lccdf_defective_3_test.cpp
@@ -0,0 +1,58 @@
+#include <stan/math/mix.hpp>
+#include <test/unit/math/test_ad.hpp>
+#include <test/unit/math/mix/prob/util.hpp>
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_w_v) {
+  auto f_y_w_v = [](const auto& a, const auto& t0, const auto& sv,
+                    const auto& sw, const auto& st0) {
+    return [&a, &t0, &sv, &sw, &st0](const auto& y, const auto& w,
+                                     const auto& v) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_w_v(a, t0, sv, sw, st0), y, w, v);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_w_sv) {
+  auto f_y_w_sv = [](const auto& a, const auto& t0, const auto& v,
+                     const auto& sw, const auto& st0) {
+    return [&a, &t0, &v, &sw, &st0](const auto& y, const auto& w,
+                                    const auto& sv) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_w_sv(a, t0, v, sw, st0), y, w, sv);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_w_sw) {
+  auto f_y_w_sw = [](const auto& a, const auto& t0, const auto& v,
+                     const auto& sv, const auto& st0) {
+    return [&a, &t0, &v, &sv, &st0](const auto& y, const auto& w,
+                                    const auto& sw) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_w_sw(a, t0, v, sv, st0), y, w, sw);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_w_st0) {
+  auto f_y_w_st0 = [](const auto& a, const auto& t0, const auto& v,
+                      const auto& sv, const auto& sw) {
+    return [&a, &t0, &v, &sv, &sw](const auto& y, const auto& w,
+                                   const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_w_st0(a, t0, v, sv, sw), y, w, st0);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_v_sv) {
+  auto f_y_v_sv = [](const auto& a, const auto& t0, const auto& w,
+                     const auto& sw, const auto& st0) {
+    return [&a, &t0, &w, &sw, &st0](const auto& y, const auto& v,
+                                    const auto& sv) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_v_sv(a, t0, w, sw, st0), y, v, sv);
+}
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_defective_4_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_defective_4_test.cpp
new file mode 100644
index 00000000000..6d92dae495e
--- /dev/null
+++ b/test/unit/math/mix/prob/wiener_full_lccdf_defective_4_test.cpp
@@ -0,0 +1,58 @@
+#include <stan/math/mix.hpp>
+#include <test/unit/math/test_ad.hpp>
+#include <test/unit/math/mix/prob/util.hpp>
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_v_sw) {
+  auto f_y_v_sw = [](const auto& a, const auto& t0, const auto& w,
+                     const auto& sv, const auto& st0) {
+    return [&a, &t0, &w, &sv, &st0](const auto& y, const auto& v,
+                                    const auto& sw) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_v_sw(a, t0, w, sv, st0), y, v, sw);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_v_st0) {
+  auto f_y_v_st0 = [](const auto& a, const auto& t0, const auto& w,
+                      const auto& sv, const auto& sw) {
+    return [&a, &t0, &w, &sv, &sw](const auto& y, const auto& v,
+                                   const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_v_st0(a, t0, w, sv, sw), y, v, st0);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_sv_sw) {
+  auto f_y_sv_sw = [](const auto& a, const auto& t0, const auto& w,
+                      const auto& v, const auto& st0) {
+    return [&a, &t0, &w, &v, &st0](const auto& y, const auto& sv,
+                                   const auto& sw) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_sv_sw(a, t0, w, v, st0), y, sv, sw);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_sv_st0) {
+  auto f_y_sv_st0 = [](const auto& a, const auto& t0, const auto& w,
+                       const auto& v, const auto& sw) {
+    return [&a, &t0, &w, &v, &sw](const auto& y, const auto& sv,
+                                  const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_sv_st0(a, t0, w, v, sw), y, sv, st0);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_y_sw_st0) {
+  auto f_y_sw_st0 = [](const auto& a, const auto& t0, const auto& w,
+                       const auto& v, const auto& sv) {
+    return [&a, &t0, &w, &v, &sv](const auto& y, const auto& sw,
+                                  const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_y_sw_st0(a, t0, w, v, sv), y, sw, st0);
+}
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_defective_5_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_defective_5_test.cpp
new file mode 100644
index 00000000000..f022d3ff300
--- /dev/null
+++ b/test/unit/math/mix/prob/wiener_full_lccdf_defective_5_test.cpp
@@ -0,0 +1,58 @@
+#include <stan/math/mix.hpp>
+#include <test/unit/math/test_ad.hpp>
+#include <test/unit/math/mix/prob/util.hpp>
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_a_t0_w) {
+  auto f_a_t0_w = [](const auto& y, const auto& v, const auto& sv,
+                     const auto& sw, const auto& st0) {
+    return [&y, &v, &sv, &sw, &st0](const auto& a, const auto& t0,
+                                    const auto& w) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_a_t0_w(y, v, sv, sw, st0), a, t0, w);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_a_t0_v) {
+  auto f_a_t0_v = [](const auto& y, const auto& w, const auto& sv,
+                     const auto& sw, const auto& st0) {
+    return [&y, &w, &sv, &sw, &st0](const auto& a, const auto& t0,
+                                    const auto& v) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_a_t0_v(y, w, sv, sw, st0), a, t0, v);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_a_t0_sv) {
+  auto f_a_t0_sv = [](const auto& y, const auto& w, const auto& v,
+                      const auto& sw, const auto& st0) {
+    return [&y, &w, &v, &sw, &st0](const auto& a, const auto& t0,
+                                   const auto& sv) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_a_t0_sv(y, w, v, sw, st0), a, t0, sv);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_a_t0_sw) {
+  auto f_a_t0_sw = [](const auto& y, const auto& w, const auto& v,
+                      const auto& sv, const auto& st0) {
+    return [&y, &w, &v, &sv, &st0](const auto& a, const auto& t0,
+                                   const auto& sw) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_a_t0_sw(y, w, v, sv, st0), a, t0, sw);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_a_t0_st0) {
+  auto f_a_t0_st0 = [](const auto& y, const auto& w, const auto& v,
+                       const auto& sv, const auto& sw) {
+    return [&y, &w, &v, &sv, &sw](const auto& a, const auto& t0,
+                                  const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_a_t0_st0(y, w, v, sv, sw), a, t0, st0);
+}
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_defective_6_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_defective_6_test.cpp
new file mode 100644
index 00000000000..4356dbaffaa
--- /dev/null
+++ b/test/unit/math/mix/prob/wiener_full_lccdf_defective_6_test.cpp
@@ -0,0 +1,58 @@
+#include <stan/math/mix.hpp>
+#include <test/unit/math/test_ad.hpp>
+#include <test/unit/math/mix/prob/util.hpp>
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_a_w_v) {
+  auto f_a_w_v = [](const auto& y, const auto& t0, const auto& sv,
+                    const auto& sw, const auto& st0) {
+    return [&y, &t0, &sv, &sw, &st0](const auto& a, const auto& w,
+                                     const auto& v) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_a_w_v(y, t0, sv, sw, st0), a, w, v);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_a_w_sv) {
+  auto f_a_w_sv = [](const auto& y, const auto& t0, const auto& v,
+                     const auto& sw, const auto& st0) {
+    return [&y, &t0, &v, &sw, &st0](const auto& a, const auto& w,
+                                    const auto& sv) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_a_w_sv(y, t0, v, sw, st0), a, w, sv);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_a_w_sw) {
+  auto f_a_w_sw = [](const auto& y, const auto& t0, const auto& v,
+                     const auto& sv, const auto& st0) {
+    return [&y, &t0, &v, &sv, &st0](const auto& a, const auto& w,
+                                    const auto& sw) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_a_w_sw(y, t0, v, sv, st0), a, w, sw);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_a_w_st0) {
+  auto f_a_w_st0 = [](const auto& y, const auto& t0, const auto& v,
+                      const auto& sv, const auto& sw) {
+    return [&y, &t0, &v, &sv, &sw](const auto& a, const auto& w,
+                                   const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_a_w_st0(y, t0, v, sv, sw), a, w, st0);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_a_v_sv) {
+  auto f_a_v_sv = [](const auto& y, const auto& t0, const auto& w,
+                     const auto& sw, const auto& st0) {
+    return [&y, &t0, &w, &sw, &st0](const auto& a, const auto& v,
+                                    const auto& sv) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_a_v_sv(y, t0, w, sw, st0), a, v, sv);
+}
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_defective_7_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_defective_7_test.cpp
new file mode 100644
index 00000000000..cafe245cfdf
--- /dev/null
+++ b/test/unit/math/mix/prob/wiener_full_lccdf_defective_7_test.cpp
@@ -0,0 +1,58 @@
+#include <stan/math/mix.hpp>
+#include <test/unit/math/test_ad.hpp>
+#include <test/unit/math/mix/prob/util.hpp>
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_a_v_sw) {
+  auto f_a_v_sw = [](const auto& y, const auto& t0, const auto& w,
+                     const auto& sv, const auto& st0) {
+    return [&y, &t0, &w, &sv, &st0](const auto& a, const auto& v,
+                                    const auto& sw) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_a_v_sw(y, t0, w, sv, st0), a, v, sw);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_a_v_st0) {
+  auto f_a_v_st0 = [](const auto& y, const auto& t0, const auto& w,
+                      const auto& sv, const auto& sw) {
+    return [&y, &t0, &w, &sv, &sw](const auto& a, const auto& v,
+                                   const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_a_v_st0(y, t0, w, sv, sw), a, v, st0);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_a_sv_sw) {
+  auto f_a_sv_sw = [](const auto& y, const auto& t0, const auto& w,
+                      const auto& v, const auto& st0) {
+    return [&y, &t0, &w, &v, &st0](const auto& a, const auto& sv,
+                                   const auto& sw) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_a_sv_sw(y, t0, w, v, st0), a, sv, sw);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_a_sv_st0) {
+  auto f_a_sv_st0 = [](const auto& y, const auto& t0, const auto& w,
+                       const auto& v, const auto& sw) {
+    return [&y, &t0, &w, &v, &sw](const auto& a, const auto& sv,
+                                  const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_a_sv_st0(y, t0, w, v, sw), a, sv, st0);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_a_sw_st0) {
+  auto f_a_sw_st0 = [](const auto& y, const auto& t0, const auto& w,
+                       const auto& v, const auto& sv) {
+    return [&y, &t0, &w, &v, &sv](const auto& a, const auto& sw,
+                                  const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_a_sw_st0(y, t0, w, v, sv), a, sw, st0);
+}
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_defective_8_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_defective_8_test.cpp
new file mode 100644
index 00000000000..667dd01611b
--- /dev/null
+++ b/test/unit/math/mix/prob/wiener_full_lccdf_defective_8_test.cpp
@@ -0,0 +1,58 @@
+#include <stan/math/mix.hpp>
+#include <test/unit/math/test_ad.hpp>
+#include <test/unit/math/mix/prob/util.hpp>
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_t0_w_v) {
+  auto f_t0_w_v = [](const auto& y, const auto& a, const auto& sv,
+                     const auto& sw, const auto& st0) {
+    return [&y, &a, &sv, &sw, &st0](const auto& t0, const auto& w,
+                                    const auto& v) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_t0_w_v(y, a, sv, sw, st0), t0, w, v);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_t0_w_sv) {
+  auto f_t0_w_sv = [](const auto& y, const auto& a, const auto& v,
+                      const auto& sw, const auto& st0) {
+    return [&y, &a, &v, &sw, &st0](const auto& t0, const auto& w,
+                                   const auto& sv) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_t0_w_sv(y, a, v, sw, st0), t0, w, sv);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_t0_w_sw) {
+  auto f_t0_w_sw = [](const auto& y, const auto& a, const auto& v,
+                      const auto& sv, const auto& st0) {
+    return [&y, &a, &v, &sv, &st0](const auto& t0, const auto& w,
+                                   const auto& sw) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_t0_w_sw(y, a, v, sv, st0), t0, w, sw);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_t0_w_st0) {
+  auto f_t0_w_st0 = [](const auto& y, const auto& a, const auto& v,
+                       const auto& sv, const auto& sw) {
+    return [&y, &a, &v, &sv, &sw](const auto& t0, const auto& w,
+                                  const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_t0_w_st0(y, a, v, sv, sw), t0, w, st0);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_t0_v_sv) {
+  auto f_t0_v_sv = [](const auto& y, const auto& a, const auto& w,
+                      const auto& sw, const auto& st0) {
+    return [&y, &a, &w, &sw, &st0](const auto& t0, const auto& v,
+                                   const auto& sv) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_t0_v_sv(y, a, w, sw, st0), t0, v, sv);
+}
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_defective_9_test.cpp b/test/unit/math/mix/prob/wiener_full_lccdf_defective_9_test.cpp
new file mode 100644
index 00000000000..fcdc84be74c
--- /dev/null
+++ b/test/unit/math/mix/prob/wiener_full_lccdf_defective_9_test.cpp
@@ -0,0 +1,58 @@
+#include <stan/math/mix.hpp>
+#include <test/unit/math/test_ad.hpp>
+#include <test/unit/math/mix/prob/util.hpp>
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_t0_v_sw) {
+  auto f_t0_v_sw = [](const auto& y, const auto& a, const auto& w,
+                      const auto& sv, const auto& st0) {
+    return [&y, &a, &w, &sv, &st0](const auto& t0, const auto& v,
+                                   const auto& sw) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_t0_v_sw(y, a, w, sv, st0), t0, v, sw);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_t0_v_st0) {
+  auto f_t0_v_st0 = [](const auto& y, const auto& a, const auto& w,
+                       const auto& sv, const auto& sw) {
+    return [&y, &a, &w, &sv, &sw](const auto& t0, const auto& v,
+                                  const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_t0_v_st0(y, a, w, sv, sw), t0, v, st0);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_t0_sv_sw) {
+  auto f_t0_sv_sw = [](const auto& y, const auto& a, const auto& w,
+                       const auto& v, const auto& st0) {
+    return [&y, &a, &w, &v, &st0](const auto& t0, const auto& sv,
+                                  const auto& sw) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_t0_sv_sw(y, a, w, v, st0), t0, sv, sw);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_t0_sv_st0) {
+  auto f_t0_sv_st0 = [](const auto& y, const auto& a, const auto& w,
+                        const auto& v, const auto& sw) {
+    return [&y, &a, &w, &v, &sw](const auto& t0, const auto& sv,
+                                 const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_t0_sv_st0(y, a, w, v, sw), t0, sv, st0);
+}
+
+TEST_F(Wiener7MixArgs, wiener_lccdf_defective_t0_sw_st0) {
+  auto f_t0_sw_st0 = [](const auto& y, const auto& a, const auto& w,
+                        const auto& v, const auto& sv) {
+    return [&y, &a, &w, &v, &sv](const auto& t0, const auto& sw,
+                                 const auto& st0) {
+      return stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
+    };
+  };
+  stan::test::expect_ad(f_t0_sw_st0(y, a, w, v, sv), t0, sw, st0);
+}
diff --git a/test/unit/math/mix/prob/wiener_full_lcdf_10_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_10_test.cpp
deleted file mode 100644
index 5aa2c43df18..00000000000
--- a/test/unit/math/mix/prob/wiener_full_lcdf_10_test.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stan/math/mix.hpp>
-#include <test/unit/math/test_ad.hpp>
-#include <test/unit/math/mix/prob/util.hpp>
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_w_v_sv) {
-  auto f_w_v_sv = [](const auto& y, const auto& a, const auto& t0,
-                     const auto& sw, const auto& st0) {
-    return
-        [&y, &a, &t0, &sw, &st0](const auto& w, const auto& v, const auto& sv) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_w_v_sv(y, a, t0, sw, st0), w, v, sv);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_w_v_sw) {
-  auto f_w_v_sw = [](const auto& y, const auto& a, const auto& t0,
-                     const auto& sv, const auto& st0) {
-    return
-        [&y, &a, &t0, &sv, &st0](const auto& w, const auto& v, const auto& sw) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_w_v_sw(y, a, t0, sv, st0), w, v, sw);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_w_v_st0) {
-  auto f_w_v_st0 = [](const auto& y, const auto& a, const auto& t0,
-                      const auto& sv, const auto& sw) {
-    return
-        [&y, &a, &t0, &sv, &sw](const auto& w, const auto& v, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_w_v_st0(y, a, t0, sv, sw), w, v, st0);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_w_sv_sw) {
-  auto f_w_sv_sw = [](const auto& y, const auto& a, const auto& t0,
-                      const auto& v, const auto& st0) {
-    return
-        [&y, &a, &t0, &v, &st0](const auto& w, const auto& sv, const auto& sw) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_w_sv_sw(y, a, t0, v, st0), w, sv, sw);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_w_sv_st0) {
-  auto f_w_sv_st0 = [](const auto& y, const auto& a, const auto& t0,
-                       const auto& v, const auto& sw) {
-    return
-        [&y, &a, &t0, &v, &sw](const auto& w, const auto& sv, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_w_sv_st0(y, a, t0, v, sw), w, sv, st0);
-}
diff --git a/test/unit/math/mix/prob/wiener_full_lcdf_2_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_2_test.cpp
deleted file mode 100644
index a628fa7da98..00000000000
--- a/test/unit/math/mix/prob/wiener_full_lcdf_2_test.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stan/math/mix.hpp>
-#include <test/unit/math/test_ad.hpp>
-#include <test/unit/math/mix/prob/util.hpp>
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_t0_w) {
-  auto f_y_t0_w = [](const auto& a, const auto& v, const auto& sv,
-                     const auto& sw, const auto& st0) {
-    return
-        [&a, &v, &sv, &sw, &st0](const auto& y, const auto& t0, const auto& w) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_t0_w(a, v, sv, sw, st0), y, t0, w);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_t0_v) {
-  auto f_y_t0_v = [](const auto& a, const auto& w, const auto& sv,
-                     const auto& sw, const auto& st0) {
-    return
-        [&a, &w, &sv, &sw, &st0](const auto& y, const auto& t0, const auto& v) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_t0_v(a, w, sv, sw, st0), y, t0, v);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_t0_sv) {
-  auto f_y_t0_sv = [](const auto& a, const auto& w, const auto& v,
-                      const auto& sw, const auto& st0) {
-    return
-        [&a, &w, &v, &sw, &st0](const auto& y, const auto& t0, const auto& sv) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_t0_sv(a, w, v, sw, st0), y, t0, sv);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_t0_sw) {
-  auto f_y_t0_sw = [](const auto& a, const auto& w, const auto& v,
-                      const auto& sv, const auto& st0) {
-    return
-        [&a, &w, &v, &sv, &st0](const auto& y, const auto& t0, const auto& sw) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_t0_sw(a, w, v, sv, st0), y, t0, sw);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_t0_st0) {
-  auto f_y_t0_st0 = [](const auto& a, const auto& w, const auto& v,
-                       const auto& sv, const auto& sw) {
-    return
-        [&a, &w, &v, &sv, &sw](const auto& y, const auto& t0, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_y_t0_st0(a, w, v, sv, sw), y, t0, st0);
-}
diff --git a/test/unit/math/mix/prob/wiener_full_lcdf_5_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_5_test.cpp
deleted file mode 100644
index 10adf45a2bc..00000000000
--- a/test/unit/math/mix/prob/wiener_full_lcdf_5_test.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stan/math/mix.hpp>
-#include <test/unit/math/test_ad.hpp>
-#include <test/unit/math/mix/prob/util.hpp>
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_a_t0_w) {
-  auto f_a_t0_w = [](const auto& y, const auto& v, const auto& sv,
-                     const auto& sw, const auto& st0) {
-    return
-        [&y, &v, &sv, &sw, &st0](const auto& a, const auto& t0, const auto& w) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_a_t0_w(y, v, sv, sw, st0), a, t0, w);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_a_t0_v) {
-  auto f_a_t0_v = [](const auto& y, const auto& w, const auto& sv,
-                     const auto& sw, const auto& st0) {
-    return
-        [&y, &w, &sv, &sw, &st0](const auto& a, const auto& t0, const auto& v) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_a_t0_v(y, w, sv, sw, st0), a, t0, v);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_a_t0_sv) {
-  auto f_a_t0_sv = [](const auto& y, const auto& w, const auto& v,
-                      const auto& sw, const auto& st0) {
-    return
-        [&y, &w, &v, &sw, &st0](const auto& a, const auto& t0, const auto& sv) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_a_t0_sv(y, w, v, sw, st0), a, t0, sv);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_a_t0_sw) {
-  auto f_a_t0_sw = [](const auto& y, const auto& w, const auto& v,
-                      const auto& sv, const auto& st0) {
-    return
-        [&y, &w, &v, &sv, &st0](const auto& a, const auto& t0, const auto& sw) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_a_t0_sw(y, w, v, sv, st0), a, t0, sw);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_a_t0_st0) {
-  auto f_a_t0_st0 = [](const auto& y, const auto& w, const auto& v,
-                       const auto& sv, const auto& sw) {
-    return
-        [&y, &w, &v, &sv, &sw](const auto& a, const auto& t0, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_a_t0_st0(y, w, v, sv, sw), a, t0, st0);
-}
diff --git a/test/unit/math/mix/prob/wiener_full_lcdf_6_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_6_test.cpp
deleted file mode 100644
index c9f8833d902..00000000000
--- a/test/unit/math/mix/prob/wiener_full_lcdf_6_test.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stan/math/mix.hpp>
-#include <test/unit/math/test_ad.hpp>
-#include <test/unit/math/mix/prob/util.hpp>
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_a_w_v) {
-  auto f_a_w_v = [](const auto& y, const auto& t0, const auto& sv,
-                    const auto& sw, const auto& st0) {
-    return
-        [&y, &t0, &sv, &sw, &st0](const auto& a, const auto& w, const auto& v) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_a_w_v(y, t0, sv, sw, st0), a, w, v);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_a_w_sv) {
-  auto f_a_w_sv = [](const auto& y, const auto& t0, const auto& v,
-                     const auto& sw, const auto& st0) {
-    return
-        [&y, &t0, &v, &sw, &st0](const auto& a, const auto& w, const auto& sv) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_a_w_sv(y, t0, v, sw, st0), a, w, sv);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_a_w_sw) {
-  auto f_a_w_sw = [](const auto& y, const auto& t0, const auto& v,
-                     const auto& sv, const auto& st0) {
-    return
-        [&y, &t0, &v, &sv, &st0](const auto& a, const auto& w, const auto& sw) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_a_w_sw(y, t0, v, sv, st0), a, w, sw);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_a_w_st0) {
-  auto f_a_w_st0 = [](const auto& y, const auto& t0, const auto& v,
-                      const auto& sv, const auto& sw) {
-    return
-        [&y, &t0, &v, &sv, &sw](const auto& a, const auto& w, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_a_w_st0(y, t0, v, sv, sw), a, w, st0);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_a_v_sv) {
-  auto f_a_v_sv = [](const auto& y, const auto& t0, const auto& w,
-                     const auto& sw, const auto& st0) {
-    return
-        [&y, &t0, &w, &sw, &st0](const auto& a, const auto& v, const auto& sv) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_a_v_sv(y, t0, w, sw, st0), a, v, sv);
-}
diff --git a/test/unit/math/mix/prob/wiener_full_lcdf_7_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_7_test.cpp
deleted file mode 100644
index fe6d6061037..00000000000
--- a/test/unit/math/mix/prob/wiener_full_lcdf_7_test.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stan/math/mix.hpp>
-#include <test/unit/math/test_ad.hpp>
-#include <test/unit/math/mix/prob/util.hpp>
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_a_v_sw) {
-  auto f_a_v_sw = [](const auto& y, const auto& t0, const auto& w,
-                     const auto& sv, const auto& st0) {
-    return
-        [&y, &t0, &w, &sv, &st0](const auto& a, const auto& v, const auto& sw) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_a_v_sw(y, t0, w, sv, st0), a, v, sw);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_a_v_st0) {
-  auto f_a_v_st0 = [](const auto& y, const auto& t0, const auto& w,
-                      const auto& sv, const auto& sw) {
-    return
-        [&y, &t0, &w, &sv, &sw](const auto& a, const auto& v, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_a_v_st0(y, t0, w, sv, sw), a, v, st0);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_a_sv_sw) {
-  auto f_a_sv_sw = [](const auto& y, const auto& t0, const auto& w,
-                      const auto& v, const auto& st0) {
-    return
-        [&y, &t0, &w, &v, &st0](const auto& a, const auto& sv, const auto& sw) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_a_sv_sw(y, t0, w, v, st0), a, sv, sw);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_a_sv_st0) {
-  auto f_a_sv_st0 = [](const auto& y, const auto& t0, const auto& w,
-                       const auto& v, const auto& sw) {
-    return
-        [&y, &t0, &w, &v, &sw](const auto& a, const auto& sv, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_a_sv_st0(y, t0, w, v, sw), a, sv, st0);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_a_sw_st0) {
-  auto f_a_sw_st0 = [](const auto& y, const auto& t0, const auto& w,
-                       const auto& v, const auto& sv) {
-    return
-        [&y, &t0, &w, &v, &sv](const auto& a, const auto& sw, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_a_sw_st0(y, t0, w, v, sv), a, sw, st0);
-}
diff --git a/test/unit/math/mix/prob/wiener_full_lcdf_9_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_9_test.cpp
deleted file mode 100644
index 566b5ff4c83..00000000000
--- a/test/unit/math/mix/prob/wiener_full_lcdf_9_test.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <stan/math/mix.hpp>
-#include <test/unit/math/test_ad.hpp>
-#include <test/unit/math/mix/prob/util.hpp>
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_t0_v_sw) {
-  auto f_t0_v_sw = [](const auto& y, const auto& a, const auto& w,
-                      const auto& sv, const auto& st0) {
-    return
-        [&y, &a, &w, &sv, &st0](const auto& t0, const auto& v, const auto& sw) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_t0_v_sw(y, a, w, sv, st0), t0, v, sw);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_t0_v_st0) {
-  auto f_t0_v_st0 = [](const auto& y, const auto& a, const auto& w,
-                       const auto& sv, const auto& sw) {
-    return
-        [&y, &a, &w, &sv, &sw](const auto& t0, const auto& v, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_t0_v_st0(y, a, w, sv, sw), t0, v, st0);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_t0_sv_sw) {
-  auto f_t0_sv_sw = [](const auto& y, const auto& a, const auto& w,
-                       const auto& v, const auto& st0) {
-    return
-        [&y, &a, &w, &v, &st0](const auto& t0, const auto& sv, const auto& sw) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_t0_sv_sw(y, a, w, v, st0), t0, sv, sw);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_t0_sv_st0) {
-  auto f_t0_sv_st0 = [](const auto& y, const auto& a, const auto& w,
-                        const auto& v, const auto& sw) {
-    return
-        [&y, &a, &w, &v, &sw](const auto& t0, const auto& sv, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_t0_sv_st0(y, a, w, v, sw), t0, sv, st0);
-}
-
-TEST_F(Wiener7MixArgs, wiener_lcdf_t0_sw_st0) {
-  auto f_t0_sw_st0 = [](const auto& y, const auto& a, const auto& w,
-                        const auto& v, const auto& sv) {
-    return
-        [&y, &a, &w, &v, &sv](const auto& t0, const auto& sw, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
-        };
-  };
-  stan::test::expect_ad(f_t0_sw_st0(y, a, w, v, sv), t0, sw, st0);
-}
diff --git a/test/unit/math/mix/prob/wiener_full_lcdf_0_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_defective_0_test.cpp
similarity index 66%
rename from test/unit/math/mix/prob/wiener_full_lcdf_0_test.cpp
rename to test/unit/math/mix/prob/wiener_full_lcdf_defective_0_test.cpp
index 0dd7b4306f2..295dbf05789 100644
--- a/test/unit/math/mix/prob/wiener_full_lcdf_0_test.cpp
+++ b/test/unit/math/mix/prob/wiener_full_lcdf_defective_0_test.cpp
@@ -2,7 +2,7 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST(mathMixDouble, wiener_lcdf) {
+TEST(mathMixDouble, wiener_lcdf_defective) {
   double y = 1.0;
   double a = 2.0;
   double t0 = 0.2;
@@ -11,10 +11,10 @@ TEST(mathMixDouble, wiener_lcdf) {
   double sv = 0.2;
   double sw = 0.2;
   double st0 = 0.2;
-  stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0, 1e-4);
+  stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0, 1e-4);
 }
 
-TEST(mathMixVar, wiener_lcdf) {
+TEST(mathMixVar, wiener_lcdf_defective) {
   using stan::math::var;
   var y = 1.0;
   var a = 2.0;
@@ -24,10 +24,10 @@ TEST(mathMixVar, wiener_lcdf) {
   var sv = 0.2;
   var sw = 0;
   var st0 = 0.2;
-  stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+  stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
 }
 
-TEST(mathMixFVar, wiener_lcdf) {
+TEST(mathMixFVar, wiener_lcdf_defective) {
   using stan::math::fvar;
   using stan::math::var;
   fvar<var> y = 1.0;
@@ -38,15 +38,15 @@ TEST(mathMixFVar, wiener_lcdf) {
   fvar<var> sv = 0.2;
   fvar<var> sw = 0;
   fvar<var> st0 = 0.2;
-  stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+  stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_a_t0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_a_t0) {
   auto f_y_a_t0 = [](const auto& w, const auto& v, const auto& sv,
                      const auto& sw, const auto& st0) {
     return
         [&w, &v, &sv, &sw, &st0](const auto& y, const auto& a, const auto& t0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_a_t0(w, v, sv, sw, st0), y, a, t0);
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_10_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_defective_10_test.cpp
similarity index 70%
rename from test/unit/math/mix/prob/wiener_full_lccdf_10_test.cpp
rename to test/unit/math/mix/prob/wiener_full_lcdf_defective_10_test.cpp
index e7eca727b91..92c675bb85a 100644
--- a/test/unit/math/mix/prob/wiener_full_lccdf_10_test.cpp
+++ b/test/unit/math/mix/prob/wiener_full_lcdf_defective_10_test.cpp
@@ -2,56 +2,56 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_w_v_sv) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_w_v_sv) {
   auto f_w_v_sv = [](const auto& y, const auto& a, const auto& t0,
                      const auto& sw, const auto& st0) {
     return
         [&y, &a, &t0, &sw, &st0](const auto& w, const auto& v, const auto& sv) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_w_v_sv(y, a, t0, sw, st0), w, v, sv);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_w_v_sw) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_w_v_sw) {
   auto f_w_v_sw = [](const auto& y, const auto& a, const auto& t0,
                      const auto& sv, const auto& st0) {
     return
         [&y, &a, &t0, &sv, &st0](const auto& w, const auto& v, const auto& sw) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_w_v_sw(y, a, t0, sv, st0), w, v, sw);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_w_v_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_w_v_st0) {
   auto f_w_v_st0 = [](const auto& y, const auto& a, const auto& t0,
                       const auto& sv, const auto& sw) {
     return
         [&y, &a, &t0, &sv, &sw](const auto& w, const auto& v, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_w_v_st0(y, a, t0, sv, sw), w, v, st0);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_w_sv_sw) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_w_sv_sw) {
   auto f_w_sv_sw = [](const auto& y, const auto& a, const auto& t0,
                       const auto& v, const auto& st0) {
     return
         [&y, &a, &t0, &v, &st0](const auto& w, const auto& sv, const auto& sw) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_w_sv_sw(y, a, t0, v, st0), w, sv, sw);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_w_sv_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_w_sv_st0) {
   auto f_w_sv_st0 = [](const auto& y, const auto& a, const auto& t0,
                        const auto& v, const auto& sw) {
     return
         [&y, &a, &t0, &v, &sw](const auto& w, const auto& sv, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_w_sv_st0(y, a, t0, v, sw), w, sv, st0);
diff --git a/test/unit/math/mix/prob/wiener_full_lcdf_11_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_defective_11_test.cpp
similarity index 70%
rename from test/unit/math/mix/prob/wiener_full_lcdf_11_test.cpp
rename to test/unit/math/mix/prob/wiener_full_lcdf_defective_11_test.cpp
index 765f21df6dd..410f21fe073 100644
--- a/test/unit/math/mix/prob/wiener_full_lcdf_11_test.cpp
+++ b/test/unit/math/mix/prob/wiener_full_lcdf_defective_11_test.cpp
@@ -2,56 +2,56 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_w_sw_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_w_sw_st0) {
   auto f_w_sw_st0 = [](const auto& y, const auto& a, const auto& t0,
                        const auto& v, const auto& sv) {
     return
         [&y, &a, &t0, &v, &sv](const auto& w, const auto& sw, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_w_sw_st0(y, a, t0, v, sv), w, sw, st0);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_v_sv_sw) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_v_sv_sw) {
   auto f_v_sv_sw = [](const auto& y, const auto& a, const auto& t0,
                       const auto& w, const auto& st0) {
     return
         [&y, &a, &t0, &w, &st0](const auto& v, const auto& sv, const auto& sw) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_v_sv_sw(y, a, t0, w, st0), v, sv, sw);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_v_sv_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_v_sv_st0) {
   auto f_v_sv_st0 = [](const auto& y, const auto& a, const auto& t0,
                        const auto& w, const auto& sw) {
     return
         [&y, &a, &t0, &w, &sw](const auto& v, const auto& sv, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_v_sv_st0(y, a, t0, w, sw), v, sv, st0);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_v_sw_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_v_sw_st0) {
   auto f_v_sw_st0 = [](const auto& y, const auto& a, const auto& t0,
                        const auto& w, const auto& sv) {
     return
         [&y, &a, &t0, &w, &sv](const auto& v, const auto& sw, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_v_sw_st0(y, a, t0, w, sv), v, sw, st0);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_sv_sw_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_sv_sw_st0) {
   auto f_sv_sw_st0 = [](const auto& y, const auto& a, const auto& t0,
                         const auto& w, const auto& v) {
     return
         [&y, &a, &t0, &w, &v](const auto& sv, const auto& sw, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_sv_sw_st0(y, a, t0, w, v), sv, sw, st0);
diff --git a/test/unit/math/mix/prob/wiener_full_lcdf_1_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_defective_1_test.cpp
similarity index 70%
rename from test/unit/math/mix/prob/wiener_full_lcdf_1_test.cpp
rename to test/unit/math/mix/prob/wiener_full_lcdf_defective_1_test.cpp
index 27e7c7b7cf3..c3d016fd71d 100644
--- a/test/unit/math/mix/prob/wiener_full_lcdf_1_test.cpp
+++ b/test/unit/math/mix/prob/wiener_full_lcdf_defective_1_test.cpp
@@ -2,56 +2,56 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_a_w) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_a_w) {
   auto f_y_a_w = [](const auto& t0, const auto& v, const auto& sv,
                     const auto& sw, const auto& st0) {
     return
         [&t0, &v, &sv, &sw, &st0](const auto& y, const auto& a, const auto& w) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_a_w(t0, v, sv, sw, st0), y, a, w);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_a_v) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_a_v) {
   auto f_y_a_v = [](const auto& t0, const auto& w, const auto& sv,
                     const auto& sw, const auto& st0) {
     return
         [&t0, &w, &sv, &sw, &st0](const auto& y, const auto& a, const auto& v) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_a_v(t0, w, sv, sw, st0), y, a, v);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_a_sv) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_a_sv) {
   auto f_y_a_sv = [](const auto& t0, const auto& w, const auto& v,
                      const auto& sw, const auto& st0) {
     return
         [&t0, &w, &v, &sw, &st0](const auto& y, const auto& a, const auto& sv) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_a_sv(t0, w, v, sw, st0), y, a, sv);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_a_sw) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_a_sw) {
   auto f_y_a_sw = [](const auto& t0, const auto& w, const auto& v,
                      const auto& sv, const auto& st0) {
     return
         [&t0, &w, &v, &sv, &st0](const auto& y, const auto& a, const auto& sw) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_a_sw(t0, w, v, sv, st0), y, a, sw);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_a_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_a_st0) {
   auto f_y_a_st0 = [](const auto& t0, const auto& w, const auto& v,
                       const auto& sv, const auto& sw) {
     return
         [&t0, &w, &v, &sv, &sw](const auto& y, const auto& a, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_a_st0(t0, w, v, sv, sw), y, a, st0);
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_2_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_defective_2_test.cpp
similarity index 70%
rename from test/unit/math/mix/prob/wiener_full_lccdf_2_test.cpp
rename to test/unit/math/mix/prob/wiener_full_lcdf_defective_2_test.cpp
index 76aabef0e32..ff73e953d10 100644
--- a/test/unit/math/mix/prob/wiener_full_lccdf_2_test.cpp
+++ b/test/unit/math/mix/prob/wiener_full_lcdf_defective_2_test.cpp
@@ -2,56 +2,56 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_t0_w) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_t0_w) {
   auto f_y_t0_w = [](const auto& a, const auto& v, const auto& sv,
                      const auto& sw, const auto& st0) {
     return
         [&a, &v, &sv, &sw, &st0](const auto& y, const auto& t0, const auto& w) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_t0_w(a, v, sv, sw, st0), y, t0, w);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_t0_v) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_t0_v) {
   auto f_y_t0_v = [](const auto& a, const auto& w, const auto& sv,
                      const auto& sw, const auto& st0) {
     return
         [&a, &w, &sv, &sw, &st0](const auto& y, const auto& t0, const auto& v) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_t0_v(a, w, sv, sw, st0), y, t0, v);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_t0_sv) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_t0_sv) {
   auto f_y_t0_sv = [](const auto& a, const auto& w, const auto& v,
                       const auto& sw, const auto& st0) {
     return
         [&a, &w, &v, &sw, &st0](const auto& y, const auto& t0, const auto& sv) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_t0_sv(a, w, v, sw, st0), y, t0, sv);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_t0_sw) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_t0_sw) {
   auto f_y_t0_sw = [](const auto& a, const auto& w, const auto& v,
                       const auto& sv, const auto& st0) {
     return
         [&a, &w, &v, &sv, &st0](const auto& y, const auto& t0, const auto& sw) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_t0_sw(a, w, v, sv, st0), y, t0, sw);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_y_t0_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_t0_st0) {
   auto f_y_t0_st0 = [](const auto& a, const auto& w, const auto& v,
                        const auto& sv, const auto& sw) {
     return
         [&a, &w, &v, &sv, &sw](const auto& y, const auto& t0, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_t0_st0(a, w, v, sv, sw), y, t0, st0);
diff --git a/test/unit/math/mix/prob/wiener_full_lcdf_3_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_defective_3_test.cpp
similarity index 70%
rename from test/unit/math/mix/prob/wiener_full_lcdf_3_test.cpp
rename to test/unit/math/mix/prob/wiener_full_lcdf_defective_3_test.cpp
index 936ea3be317..4b1af6f13b2 100644
--- a/test/unit/math/mix/prob/wiener_full_lcdf_3_test.cpp
+++ b/test/unit/math/mix/prob/wiener_full_lcdf_defective_3_test.cpp
@@ -2,56 +2,56 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_w_v) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_w_v) {
   auto f_y_w_v = [](const auto& a, const auto& t0, const auto& sv,
                     const auto& sw, const auto& st0) {
     return
         [&a, &t0, &sv, &sw, &st0](const auto& y, const auto& w, const auto& v) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_w_v(a, t0, sv, sw, st0), y, w, v);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_w_sv) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_w_sv) {
   auto f_y_w_sv = [](const auto& a, const auto& t0, const auto& v,
                      const auto& sw, const auto& st0) {
     return
         [&a, &t0, &v, &sw, &st0](const auto& y, const auto& w, const auto& sv) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_w_sv(a, t0, v, sw, st0), y, w, sv);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_w_sw) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_w_sw) {
   auto f_y_w_sw = [](const auto& a, const auto& t0, const auto& v,
                      const auto& sv, const auto& st0) {
     return
         [&a, &t0, &v, &sv, &st0](const auto& y, const auto& w, const auto& sw) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_w_sw(a, t0, v, sv, st0), y, w, sw);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_w_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_w_st0) {
   auto f_y_w_st0 = [](const auto& a, const auto& t0, const auto& v,
                       const auto& sv, const auto& sw) {
     return
         [&a, &t0, &v, &sv, &sw](const auto& y, const auto& w, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_w_st0(a, t0, v, sv, sw), y, w, st0);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_v_sv) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_v_sv) {
   auto f_y_v_sv = [](const auto& a, const auto& t0, const auto& w,
                      const auto& sw, const auto& st0) {
     return
         [&a, &t0, &w, &sw, &st0](const auto& y, const auto& v, const auto& sv) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_v_sv(a, t0, w, sw, st0), y, v, sv);
diff --git a/test/unit/math/mix/prob/wiener_full_lcdf_4_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_defective_4_test.cpp
similarity index 70%
rename from test/unit/math/mix/prob/wiener_full_lcdf_4_test.cpp
rename to test/unit/math/mix/prob/wiener_full_lcdf_defective_4_test.cpp
index b7e0699eb47..273e5cdafe1 100644
--- a/test/unit/math/mix/prob/wiener_full_lcdf_4_test.cpp
+++ b/test/unit/math/mix/prob/wiener_full_lcdf_defective_4_test.cpp
@@ -2,56 +2,56 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_v_sw) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_v_sw) {
   auto f_y_v_sw = [](const auto& a, const auto& t0, const auto& w,
                      const auto& sv, const auto& st0) {
     return
         [&a, &t0, &w, &sv, &st0](const auto& y, const auto& v, const auto& sw) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_v_sw(a, t0, w, sv, st0), y, v, sw);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_v_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_v_st0) {
   auto f_y_v_st0 = [](const auto& a, const auto& t0, const auto& w,
                       const auto& sv, const auto& sw) {
     return
         [&a, &t0, &w, &sv, &sw](const auto& y, const auto& v, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_v_st0(a, t0, w, sv, sw), y, v, st0);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_sv_sw) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_sv_sw) {
   auto f_y_sv_sw = [](const auto& a, const auto& t0, const auto& w,
                       const auto& v, const auto& st0) {
     return
         [&a, &t0, &w, &v, &st0](const auto& y, const auto& sv, const auto& sw) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_sv_sw(a, t0, w, v, st0), y, sv, sw);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_sv_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_sv_st0) {
   auto f_y_sv_st0 = [](const auto& a, const auto& t0, const auto& w,
                        const auto& v, const auto& sw) {
     return
         [&a, &t0, &w, &v, &sw](const auto& y, const auto& sv, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_sv_st0(a, t0, w, v, sw), y, sv, st0);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_y_sw_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_y_sw_st0) {
   auto f_y_sw_st0 = [](const auto& a, const auto& t0, const auto& w,
                        const auto& v, const auto& sv) {
     return
         [&a, &t0, &w, &v, &sv](const auto& y, const auto& sw, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_y_sw_st0(a, t0, w, v, sv), y, sw, st0);
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_5_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_defective_5_test.cpp
similarity index 70%
rename from test/unit/math/mix/prob/wiener_full_lccdf_5_test.cpp
rename to test/unit/math/mix/prob/wiener_full_lcdf_defective_5_test.cpp
index f24cef06a49..4e00d376d99 100644
--- a/test/unit/math/mix/prob/wiener_full_lccdf_5_test.cpp
+++ b/test/unit/math/mix/prob/wiener_full_lcdf_defective_5_test.cpp
@@ -2,56 +2,56 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_a_t0_w) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_a_t0_w) {
   auto f_a_t0_w = [](const auto& y, const auto& v, const auto& sv,
                      const auto& sw, const auto& st0) {
     return
         [&y, &v, &sv, &sw, &st0](const auto& a, const auto& t0, const auto& w) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_a_t0_w(y, v, sv, sw, st0), a, t0, w);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_a_t0_v) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_a_t0_v) {
   auto f_a_t0_v = [](const auto& y, const auto& w, const auto& sv,
                      const auto& sw, const auto& st0) {
     return
         [&y, &w, &sv, &sw, &st0](const auto& a, const auto& t0, const auto& v) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_a_t0_v(y, w, sv, sw, st0), a, t0, v);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_a_t0_sv) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_a_t0_sv) {
   auto f_a_t0_sv = [](const auto& y, const auto& w, const auto& v,
                       const auto& sw, const auto& st0) {
     return
         [&y, &w, &v, &sw, &st0](const auto& a, const auto& t0, const auto& sv) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_a_t0_sv(y, w, v, sw, st0), a, t0, sv);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_a_t0_sw) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_a_t0_sw) {
   auto f_a_t0_sw = [](const auto& y, const auto& w, const auto& v,
                       const auto& sv, const auto& st0) {
     return
         [&y, &w, &v, &sv, &st0](const auto& a, const auto& t0, const auto& sw) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_a_t0_sw(y, w, v, sv, st0), a, t0, sw);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_a_t0_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_a_t0_st0) {
   auto f_a_t0_st0 = [](const auto& y, const auto& w, const auto& v,
                        const auto& sv, const auto& sw) {
     return
         [&y, &w, &v, &sv, &sw](const auto& a, const auto& t0, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_a_t0_st0(y, w, v, sv, sw), a, t0, st0);
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_6_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_defective_6_test.cpp
similarity index 70%
rename from test/unit/math/mix/prob/wiener_full_lccdf_6_test.cpp
rename to test/unit/math/mix/prob/wiener_full_lcdf_defective_6_test.cpp
index f98faacfa6c..9160bb86a5a 100644
--- a/test/unit/math/mix/prob/wiener_full_lccdf_6_test.cpp
+++ b/test/unit/math/mix/prob/wiener_full_lcdf_defective_6_test.cpp
@@ -2,56 +2,56 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_a_w_v) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_a_w_v) {
   auto f_a_w_v = [](const auto& y, const auto& t0, const auto& sv,
                     const auto& sw, const auto& st0) {
     return
         [&y, &t0, &sv, &sw, &st0](const auto& a, const auto& w, const auto& v) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_a_w_v(y, t0, sv, sw, st0), a, w, v);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_a_w_sv) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_a_w_sv) {
   auto f_a_w_sv = [](const auto& y, const auto& t0, const auto& v,
                      const auto& sw, const auto& st0) {
     return
         [&y, &t0, &v, &sw, &st0](const auto& a, const auto& w, const auto& sv) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_a_w_sv(y, t0, v, sw, st0), a, w, sv);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_a_w_sw) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_a_w_sw) {
   auto f_a_w_sw = [](const auto& y, const auto& t0, const auto& v,
                      const auto& sv, const auto& st0) {
     return
         [&y, &t0, &v, &sv, &st0](const auto& a, const auto& w, const auto& sw) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_a_w_sw(y, t0, v, sv, st0), a, w, sw);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_a_w_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_a_w_st0) {
   auto f_a_w_st0 = [](const auto& y, const auto& t0, const auto& v,
                       const auto& sv, const auto& sw) {
     return
         [&y, &t0, &v, &sv, &sw](const auto& a, const auto& w, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_a_w_st0(y, t0, v, sv, sw), a, w, st0);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_a_v_sv) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_a_v_sv) {
   auto f_a_v_sv = [](const auto& y, const auto& t0, const auto& w,
                      const auto& sw, const auto& st0) {
     return
         [&y, &t0, &w, &sw, &st0](const auto& a, const auto& v, const auto& sv) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_a_v_sv(y, t0, w, sw, st0), a, v, sv);
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_7_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_defective_7_test.cpp
similarity index 70%
rename from test/unit/math/mix/prob/wiener_full_lccdf_7_test.cpp
rename to test/unit/math/mix/prob/wiener_full_lcdf_defective_7_test.cpp
index f7e38df10b1..733d52363a8 100644
--- a/test/unit/math/mix/prob/wiener_full_lccdf_7_test.cpp
+++ b/test/unit/math/mix/prob/wiener_full_lcdf_defective_7_test.cpp
@@ -2,56 +2,56 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_a_v_sw) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_a_v_sw) {
   auto f_a_v_sw = [](const auto& y, const auto& t0, const auto& w,
                      const auto& sv, const auto& st0) {
     return
         [&y, &t0, &w, &sv, &st0](const auto& a, const auto& v, const auto& sw) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_a_v_sw(y, t0, w, sv, st0), a, v, sw);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_a_v_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_a_v_st0) {
   auto f_a_v_st0 = [](const auto& y, const auto& t0, const auto& w,
                       const auto& sv, const auto& sw) {
     return
         [&y, &t0, &w, &sv, &sw](const auto& a, const auto& v, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_a_v_st0(y, t0, w, sv, sw), a, v, st0);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_a_sv_sw) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_a_sv_sw) {
   auto f_a_sv_sw = [](const auto& y, const auto& t0, const auto& w,
                       const auto& v, const auto& st0) {
     return
         [&y, &t0, &w, &v, &st0](const auto& a, const auto& sv, const auto& sw) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_a_sv_sw(y, t0, w, v, st0), a, sv, sw);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_a_sv_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_a_sv_st0) {
   auto f_a_sv_st0 = [](const auto& y, const auto& t0, const auto& w,
                        const auto& v, const auto& sw) {
     return
         [&y, &t0, &w, &v, &sw](const auto& a, const auto& sv, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_a_sv_st0(y, t0, w, v, sw), a, sv, st0);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_a_sw_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_a_sw_st0) {
   auto f_a_sw_st0 = [](const auto& y, const auto& t0, const auto& w,
                        const auto& v, const auto& sv) {
     return
         [&y, &t0, &w, &v, &sv](const auto& a, const auto& sw, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_a_sw_st0(y, t0, w, v, sv), a, sw, st0);
diff --git a/test/unit/math/mix/prob/wiener_full_lcdf_8_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_defective_8_test.cpp
similarity index 70%
rename from test/unit/math/mix/prob/wiener_full_lcdf_8_test.cpp
rename to test/unit/math/mix/prob/wiener_full_lcdf_defective_8_test.cpp
index 54350c2dc46..152dc85155a 100644
--- a/test/unit/math/mix/prob/wiener_full_lcdf_8_test.cpp
+++ b/test/unit/math/mix/prob/wiener_full_lcdf_defective_8_test.cpp
@@ -2,56 +2,56 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_t0_w_v) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_t0_w_v) {
   auto f_t0_w_v = [](const auto& y, const auto& a, const auto& sv,
                      const auto& sw, const auto& st0) {
     return
         [&y, &a, &sv, &sw, &st0](const auto& t0, const auto& w, const auto& v) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_t0_w_v(y, a, sv, sw, st0), t0, w, v);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_t0_w_sv) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_t0_w_sv) {
   auto f_t0_w_sv = [](const auto& y, const auto& a, const auto& v,
                       const auto& sw, const auto& st0) {
     return
         [&y, &a, &v, &sw, &st0](const auto& t0, const auto& w, const auto& sv) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_t0_w_sv(y, a, v, sw, st0), t0, w, sv);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_t0_w_sw) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_t0_w_sw) {
   auto f_t0_w_sw = [](const auto& y, const auto& a, const auto& v,
                       const auto& sv, const auto& st0) {
     return
         [&y, &a, &v, &sv, &st0](const auto& t0, const auto& w, const auto& sw) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_t0_w_sw(y, a, v, sv, st0), t0, w, sw);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_t0_w_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_t0_w_st0) {
   auto f_t0_w_st0 = [](const auto& y, const auto& a, const auto& v,
                        const auto& sv, const auto& sw) {
     return
         [&y, &a, &v, &sv, &sw](const auto& t0, const auto& w, const auto& st0) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_t0_w_st0(y, a, v, sv, sw), t0, w, st0);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lcdf_t0_v_sv) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_t0_v_sv) {
   auto f_t0_v_sv = [](const auto& y, const auto& a, const auto& w,
                       const auto& sw, const auto& st0) {
     return
         [&y, &a, &w, &sw, &st0](const auto& t0, const auto& v, const auto& sv) {
-          return stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_t0_v_sv(y, a, w, sw, st0), t0, v, sv);
diff --git a/test/unit/math/mix/prob/wiener_full_lccdf_9_test.cpp b/test/unit/math/mix/prob/wiener_full_lcdf_defective_9_test.cpp
similarity index 70%
rename from test/unit/math/mix/prob/wiener_full_lccdf_9_test.cpp
rename to test/unit/math/mix/prob/wiener_full_lcdf_defective_9_test.cpp
index 2a8382f3693..35770c779a4 100644
--- a/test/unit/math/mix/prob/wiener_full_lccdf_9_test.cpp
+++ b/test/unit/math/mix/prob/wiener_full_lcdf_defective_9_test.cpp
@@ -2,56 +2,56 @@
 #include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/mix/prob/util.hpp>
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_t0_v_sw) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_t0_v_sw) {
   auto f_t0_v_sw = [](const auto& y, const auto& a, const auto& w,
                       const auto& sv, const auto& st0) {
     return
         [&y, &a, &w, &sv, &st0](const auto& t0, const auto& v, const auto& sw) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_t0_v_sw(y, a, w, sv, st0), t0, v, sw);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_t0_v_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_t0_v_st0) {
   auto f_t0_v_st0 = [](const auto& y, const auto& a, const auto& w,
                        const auto& sv, const auto& sw) {
     return
         [&y, &a, &w, &sv, &sw](const auto& t0, const auto& v, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_t0_v_st0(y, a, w, sv, sw), t0, v, st0);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_t0_sv_sw) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_t0_sv_sw) {
   auto f_t0_sv_sw = [](const auto& y, const auto& a, const auto& w,
                        const auto& v, const auto& st0) {
     return
         [&y, &a, &w, &v, &st0](const auto& t0, const auto& sv, const auto& sw) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_t0_sv_sw(y, a, w, v, st0), t0, sv, sw);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_t0_sv_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_t0_sv_st0) {
   auto f_t0_sv_st0 = [](const auto& y, const auto& a, const auto& w,
                         const auto& v, const auto& sw) {
     return
         [&y, &a, &w, &v, &sw](const auto& t0, const auto& sv, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_t0_sv_st0(y, a, w, v, sw), t0, sv, st0);
 }
 
-TEST_F(Wiener7MixArgs, wiener_lccdf_t0_sw_st0) {
+TEST_F(Wiener7MixArgs, wiener_lcdf_defective_t0_sw_st0) {
   auto f_t0_sw_st0 = [](const auto& y, const auto& a, const auto& w,
                         const auto& v, const auto& sv) {
     return
         [&y, &a, &w, &v, &sv](const auto& t0, const auto& sw, const auto& st0) {
-          return stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+          return stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
         };
   };
   stan::test::expect_ad(f_t0_sw_st0(y, a, w, v, sv), t0, sw, st0);
diff --git a/test/unit/math/prim/prob/wiener_full_lccdf_test.cpp b/test/unit/math/prim/prob/wiener_full_lccdf_defective_test.cpp
similarity index 59%
rename from test/unit/math/prim/prob/wiener_full_lccdf_test.cpp
rename to test/unit/math/prim/prob/wiener_full_lccdf_defective_test.cpp
index c1fdf33505d..ae8dd524d1d 100644
--- a/test/unit/math/prim/prob/wiener_full_lccdf_test.cpp
+++ b/test/unit/math/prim/prob/wiener_full_lccdf_defective_test.cpp
@@ -8,10 +8,10 @@
 
 TEST(mathPrimScalProbWienerFullLccdfScal, valid) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2,
          st0 = 0.1;
-  EXPECT_NO_THROW(wiener_lccdf(rt, a, t0, w, v, sv, sw, st0));
+  EXPECT_NO_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, sw, st0));
   rt = 5;
   a = 1;
   v = 1;
@@ -20,130 +20,150 @@ TEST(mathPrimScalProbWienerFullLccdfScal, valid) {
   sv = 0.0;
   sw = 0.0;
   st0 = 0.0;
-  EXPECT_NO_THROW(wiener_lccdf(rt, a, t0, w, v, sv, sw, st0));
+  EXPECT_NO_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, sw, st0));
 }
 
 // rt
 TEST(mathPrimScalProbWienerFullLccdfScal, invalid_rt) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lccdf(0, a, t0, w, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lccdf(-1, a, t0, w, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lccdf(INFTY, a, t0, w, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lccdf_defective(0, a, t0, w, v, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(-INFTY, a, t0, w, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lccdf_defective(-1, a, t0, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(INFTY, a, t0, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(-INFTY, a, t0, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(NAN, a, t0, w, v, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(NAN, a, t0, w, v, sv, sw, st0), std::domain_error);
 }
 
 // a
 TEST(mathPrimScalProbWienerFullLccdfScal, invalid_a) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lccdf(rt, 0, t0, w, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, -1, t0, w, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, INFTY, t0, w, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, 0, t0, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, -1, t0, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, INFTY, t0, w, v, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, -INFTY, t0, w, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, -INFTY, t0, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, NAN, t0, w, v, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, NAN, t0, w, v, sv, sw, st0), std::domain_error);
 }
 
 // v
 TEST(mathPrimScalProbWienerFullLccdfScal, invalid_v) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2,
          st0 = 0.1;
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, INFTY, sv, sw, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, INFTY, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, -INFTY, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, -INFTY, sv, sw, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, NAN, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, NAN, sv, sw, st0), std::domain_error);
 }
 
 // w
 TEST(mathPrimScalProbWienerFullLccdfScal, invalid_w) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, a = 1, v = -1, t0 = 0.1, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, -0.1, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, -0.1, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, 0, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, 1, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, 1.1, v, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, 0, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, 1, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, 1.1, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, INFTY, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, INFTY, v, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, -INFTY, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, -INFTY, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, NAN, v, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, NAN, v, sv, sw, st0), std::domain_error);
 }
 
 // t0
 TEST(mathPrimScalProbWienerFullLccdfScal, invalid_t0) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lccdf(rt, a, 2, w, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, 2, w, v, sv, sw, st0),
                std::domain_error);  // rt must be greater than t0
-  EXPECT_THROW(wiener_lccdf(rt, a, -1, w, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, INFTY, w, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, -1, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, INFTY, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, -INFTY, w, v, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, -INFTY, w, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, NAN, w, v, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, NAN, w, v, sv, sw, st0), std::domain_error);
 }
 
 // sv
 TEST(mathPrimScalProbWienerFullLccdfScal, invalid_sv) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, -1, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, INFTY, sw, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, -1, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, INFTY, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, -INFTY, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, -INFTY, sw, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, NAN, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, NAN, sw, st0), std::domain_error);
 }
 
 // sw
 TEST(mathPrimScalProbWienerFullLccdfScal, invalid_sw) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, -1, st0), std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, 0.8, v, sv, 0.5, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, -1, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, 0.8, v, sv, 0.5, st0),
                std::domain_error);  // sw must be smaller than 2*(1-w)
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, 0.3, v, sv, 0.7, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, 0.3, v, sv, 0.7, st0),
                std::domain_error);  // sw must be smaller than 2*w
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, INFTY, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, INFTY, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, -INFTY, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, -INFTY, st0),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, NAN, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, NAN, st0), std::domain_error);
 }
 
 // st0
 TEST(mathPrimScalProbWienerFullLccdfScal, invalid_st0) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2;
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, sw, -1), std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, sw, INFTY), std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, sw, -INFTY),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, sw, -1),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, sw, INFTY),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, sw, -INFTY),
+               std::domain_error);
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, sw, NAN),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, sw, NAN), std::domain_error);
 }
 
 TEST(mathPrimScalProbWienerFullLccdfPrecScal, valid) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2,
          st0 = 0.1;
-  EXPECT_NO_THROW(wiener_lccdf(rt, a, t0, w, v, sv, sw, st0, 1e-4));
+  EXPECT_NO_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, sw, st0, 1e-4));
   rt = 5;
   a = 1;
   v = 1;
@@ -152,145 +172,145 @@ TEST(mathPrimScalProbWienerFullLccdfPrecScal, valid) {
   sv = 0.0;
   sw = 0.0;
   st0 = 0.0;
-  EXPECT_NO_THROW(wiener_lccdf(rt, a, t0, w, v, sv, sw, st0, 1e-4));
+  EXPECT_NO_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, sw, st0, 1e-4));
 }
 
 // rt
 TEST(mathPrimScalProbWienerFullLccdfPrecScal, invalid_rt) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lccdf(0, a, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(0, a, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(-1, a, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(-1, a, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(INFTY, a, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(INFTY, a, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(-INFTY, a, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(-INFTY, a, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(NAN, a, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(NAN, a, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
 }
 
 // a
 TEST(mathPrimScalProbWienerFullLccdfPrecScal, invalid_a) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lccdf(rt, 0, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, 0, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, -1, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, -1, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, INFTY, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, INFTY, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, -INFTY, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, -INFTY, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, NAN, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, NAN, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
 }
 
 // v
 TEST(mathPrimScalProbWienerFullLccdfPrecScal, invalid_v) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2,
          st0 = 0.1;
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, INFTY, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, INFTY, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, -INFTY, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, -INFTY, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, NAN, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, NAN, sv, sw, st0, 1e-4),
                std::domain_error);
 }
 
 // w
 TEST(mathPrimScalProbWienerFullLccdfPrecScal, invalid_w) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, a = 1, v = -1, t0 = 0.1, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, -0.1, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, -0.1, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, 0, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, 0, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, 1, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, 1, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, 1.1, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, 1.1, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, INFTY, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, INFTY, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, -INFTY, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, -INFTY, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, NAN, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, NAN, v, sv, sw, st0, 1e-4),
                std::domain_error);
 }
 
 // t0
 TEST(mathPrimScalProbWienerFullLccdfPrecScal, invalid_t0) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lccdf(rt, a, 2, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, 2, w, v, sv, sw, st0, 1e-4),
                std::domain_error);  // rt must be greater than t0
-  EXPECT_THROW(wiener_lccdf(rt, a, -1, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, -1, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, INFTY, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, INFTY, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, -INFTY, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, -INFTY, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, NAN, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, NAN, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
 }
 
 // sv
 TEST(mathPrimScalProbWienerFullLccdfPrecScal, invalid_sv) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, -1, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, -1, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, INFTY, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, INFTY, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, -INFTY, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, -INFTY, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, NAN, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, NAN, sw, st0, 1e-4),
                std::domain_error);
 }
 
 // sw
 TEST(mathPrimScalProbWienerFullLccdfPrecScal, invalid_sw) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, -1, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, -1, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, 0.8, v, sv, 0.5, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, 0.8, v, sv, 0.5, st0, 1e-4),
                std::domain_error);  // sw must be smaller than 2*(1-w)
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, 0.3, v, sv, 0.7, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, 0.3, v, sv, 0.7, st0, 1e-4),
                std::domain_error);  // sw must be smaller than 2*w
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, INFTY, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, INFTY, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, -INFTY, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, -INFTY, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, NAN, st0, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, NAN, st0, 1e-4),
                std::domain_error);
 }
 
 // st0
 TEST(mathPrimScalProbWienerFullLccdfPrecScal, invalid_st0) {
   using stan::math::INFTY;
-  using stan::math::wiener_lccdf;
+  using stan::math::wiener_lccdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2;
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, sw, -1, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, sw, -1, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, sw, INFTY, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, sw, INFTY, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, sw, -INFTY, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, sw, -INFTY, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lccdf(rt, a, t0, w, v, sv, sw, NAN, 1e-4),
+  EXPECT_THROW(wiener_lccdf_defective(rt, a, t0, w, v, sv, sw, NAN, 1e-4),
                std::domain_error);
 }
 
-TEST(mathPrimCorrectValues, wiener_lccdf) {
+TEST(mathPrimCorrectValues, wiener_lccdf_defective) {
   /* Test concrete values. True values are computed in R using the R-package
    * WienR and the function WienerCDF() with its partial derivatives:
    * ccdf = cdf(big_value) - cdf
@@ -399,7 +419,7 @@ TEST(mathPrimCorrectValues, wiener_lccdf) {
     var sv = sv_vec[i];
     var sw = sw_vec[i];
     var st0 = st0_vec[i];
-    var lccdf = stan::math::wiener_lccdf(y, a, t0, w, v, sv, sw, st0);
+    var lccdf = stan::math::wiener_lccdf_defective(y, a, t0, w, v, sv, sw, st0);
     lccdf.grad();
     EXPECT_NEAR(lccdf.val(), true_lccdf[i], err_tol_dens);
     EXPECT_NEAR(y.adj(), true_grad_y[i], err_tol);
diff --git a/test/unit/math/prim/prob/wiener_full_lcdf_test.cpp b/test/unit/math/prim/prob/wiener_full_lcdf_defective_test.cpp
similarity index 58%
rename from test/unit/math/prim/prob/wiener_full_lcdf_test.cpp
rename to test/unit/math/prim/prob/wiener_full_lcdf_defective_test.cpp
index bf18ff38150..6e9c7765cd8 100644
--- a/test/unit/math/prim/prob/wiener_full_lcdf_test.cpp
+++ b/test/unit/math/prim/prob/wiener_full_lcdf_defective_test.cpp
@@ -8,10 +8,10 @@
 
 TEST(mathPrimScalProbWienerFullLcdfScal, valid) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2,
          st0 = 0.1;
-  EXPECT_NO_THROW(wiener_lcdf(rt, a, t0, w, v, sv, sw, st0));
+  EXPECT_NO_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, sw, st0));
   rt = 5;
   a = 1;
   v = 1;
@@ -20,124 +20,150 @@ TEST(mathPrimScalProbWienerFullLcdfScal, valid) {
   sv = 0.0;
   sw = 0.0;
   st0 = 0.0;
-  EXPECT_NO_THROW(wiener_lcdf(rt, a, t0, w, v, sv, sw, st0));
+  EXPECT_NO_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, sw, st0));
 }
 
 // rt
 TEST(mathPrimScalProbWienerFullLcdfScal, invalid_rt) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lcdf(0, a, t0, w, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(-1, a, t0, w, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(INFTY, a, t0, w, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(-INFTY, a, t0, w, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lcdf_defective(0, a, t0, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(-1, a, t0, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(INFTY, a, t0, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(-INFTY, a, t0, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(NAN, a, t0, w, v, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(NAN, a, t0, w, v, sv, sw, st0), std::domain_error);
 }
 
 // a
 TEST(mathPrimScalProbWienerFullLcdfScal, invalid_a) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lcdf(rt, 0, t0, w, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, -1, t0, w, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, INFTY, t0, w, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lcdf_defective(rt, 0, t0, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, -1, t0, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, INFTY, t0, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, -INFTY, t0, w, v, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, -INFTY, t0, w, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lcdf_defective(rt, NAN, t0, w, v, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, NAN, t0, w, v, sv, sw, st0), std::domain_error);
 }
 
 // v
 TEST(mathPrimScalProbWienerFullLcdfScal, invalid_v) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2,
          st0 = 0.1;
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, INFTY, sv, sw, st0),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, INFTY, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, -INFTY, sv, sw, st0),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, -INFTY, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, NAN, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, NAN, sv, sw, st0), std::domain_error);
 }
 
 // w
 TEST(mathPrimScalProbWienerFullLcdfScal, invalid_w) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, a = 1, v = -1, t0 = 0.1, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, -0.1, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, 0, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, 1, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, 1.1, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, INFTY, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, -0.1, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, 0, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, 1, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, 1.1, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, INFTY, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, -INFTY, v, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, -INFTY, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, NAN, v, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, NAN, v, sv, sw, st0), std::domain_error);
 }
 
 // t0
 TEST(mathPrimScalProbWienerFullLcdfScal, invalid_t0) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lcdf(rt, a, 2, w, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, 2, w, v, sv, sw, st0),
                std::domain_error);  // rt must be greater than t0
-  EXPECT_THROW(wiener_lcdf(rt, a, -1, w, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, INFTY, w, v, sv, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, -INFTY, w, v, sv, sw, st0),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, -1, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, INFTY, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, -INFTY, w, v, sv, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, NAN, w, v, sv, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, NAN, w, v, sv, sw, st0), std::domain_error);
 }
 
 // sv
 TEST(mathPrimScalProbWienerFullLcdfScal, invalid_sv) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, -1, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, INFTY, sw, st0), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, -INFTY, sw, st0),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, -1, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, INFTY, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, -INFTY, sw, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, NAN, sw, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, NAN, sw, st0), std::domain_error);
 }
 
 // sw
 TEST(mathPrimScalProbWienerFullLcdfScal, invalid_sw) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, -1, st0), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, 0.8, v, sv, 0.5, st0),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, -1, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, 0.8, v, sv, 0.5, st0),
                std::domain_error);  // sw must be smaller than 2*(1-w)
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, 0.3, v, sv, 0.7, st0),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, 0.3, v, sv, 0.7, st0),
                std::domain_error);  // sw must be smaller than 2*w
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, INFTY, st0), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, -INFTY, st0),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, INFTY, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, -INFTY, st0),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, NAN, st0),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, NAN, st0), std::domain_error);
 }
 
 // st0
 TEST(mathPrimScalProbWienerFullLcdfScal, invalid_st0) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2;
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, sw, -1), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, sw, INFTY), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, sw, -INFTY), std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, sw, NAN), std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, sw, -1),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, sw, INFTY),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, sw, -INFTY),
+               std::domain_error);
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, sw, NAN),
+               std::domain_error);
 }
 
 TEST(mathPrimScalProbWienerFullLcdfPrecScal, valid) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2,
          st0 = 0.1;
-  EXPECT_NO_THROW(wiener_lcdf(rt, a, t0, w, v, sv, sw, st0, 1e-4));
+  EXPECT_NO_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, sw, st0, 1e-4));
   rt = 5;
   a = 1;
   v = 1;
@@ -146,145 +172,145 @@ TEST(mathPrimScalProbWienerFullLcdfPrecScal, valid) {
   sv = 0.0;
   sw = 0.0;
   st0 = 0.0;
-  EXPECT_NO_THROW(wiener_lcdf(rt, a, t0, w, v, sv, sw, st0, 1e-4));
+  EXPECT_NO_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, sw, st0, 1e-4));
 }
 
 // rt
 TEST(mathPrimScalProbWienerFullLcdfPrecScal, invalid_rt) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lcdf(0, a, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(0, a, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(-1, a, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(-1, a, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(INFTY, a, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(INFTY, a, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(-INFTY, a, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(-INFTY, a, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(NAN, a, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(NAN, a, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
 }
 
 // a
 TEST(mathPrimScalProbWienerFullLcdfPrecScal, invalid_a) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lcdf(rt, 0, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, 0, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, -1, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, -1, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, INFTY, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, INFTY, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, -INFTY, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, -INFTY, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, NAN, t0, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, NAN, t0, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
 }
 
 // v
 TEST(mathPrimScalProbWienerFullLcdfPrecScal, invalid_v) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2,
          st0 = 0.1;
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, INFTY, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, INFTY, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, -INFTY, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, -INFTY, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, NAN, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, NAN, sv, sw, st0, 1e-4),
                std::domain_error);
 }
 
 // w
 TEST(mathPrimScalProbWienerFullLcdfPrecScal, invalid_w) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, a = 1, v = -1, t0 = 0.1, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, -0.1, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, -0.1, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, 0, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, 0, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, 1, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, 1, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, 1.1, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, 1.1, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, INFTY, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, INFTY, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, -INFTY, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, -INFTY, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, NAN, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, NAN, v, sv, sw, st0, 1e-4),
                std::domain_error);
 }
 
 // t0
 TEST(mathPrimScalProbWienerFullLcdfPrecScal, invalid_t0) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, sv = 0.2, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lcdf(rt, a, 2, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, 2, w, v, sv, sw, st0, 1e-4),
                std::domain_error);  // rt must be greater than t0
-  EXPECT_THROW(wiener_lcdf(rt, a, -1, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, -1, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, INFTY, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, INFTY, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, -INFTY, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, -INFTY, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, NAN, w, v, sv, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, NAN, w, v, sv, sw, st0, 1e-4),
                std::domain_error);
 }
 
 // sv
 TEST(mathPrimScalProbWienerFullLcdfPrecScal, invalid_sv) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sw = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, -1, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, -1, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, INFTY, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, INFTY, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, -INFTY, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, -INFTY, sw, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, NAN, sw, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, NAN, sw, st0, 1e-4),
                std::domain_error);
 }
 
 // sw
 TEST(mathPrimScalProbWienerFullLcdfPrecScal, invalid_sw) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, st0 = 0.1;
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, -1, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, -1, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, 0.8, v, sv, 0.5, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, 0.8, v, sv, 0.5, st0, 1e-4),
                std::domain_error);  // sw must be smaller than 2*(1-w)
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, 0.3, v, sv, 0.7, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, 0.3, v, sv, 0.7, st0, 1e-4),
                std::domain_error);  // sw must be smaller than 2*w
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, INFTY, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, INFTY, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, -INFTY, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, -INFTY, st0, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, NAN, st0, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, NAN, st0, 1e-4),
                std::domain_error);
 }
 
 // st0
 TEST(mathPrimScalProbWienerFullLcdfPrecScal, invalid_st0) {
   using stan::math::INFTY;
-  using stan::math::wiener_lcdf;
+  using stan::math::wiener_lcdf_defective;
   double rt = 1, a = 1, v = -1, w = 0.5, t0 = 0.1, sv = 0.2, sw = 0.2;
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, sw, -1, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, sw, -1, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, sw, INFTY, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, sw, INFTY, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, sw, -INFTY, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, sw, -INFTY, 1e-4),
                std::domain_error);
-  EXPECT_THROW(wiener_lcdf(rt, a, t0, w, v, sv, sw, NAN, 1e-4),
+  EXPECT_THROW(wiener_lcdf_defective(rt, a, t0, w, v, sv, sw, NAN, 1e-4),
                std::domain_error);
 }
 
-TEST(mathPrimCorrectValues, wiener_lcdf) {
+TEST(mathPrimCorrectValues, wiener_lcdf_defective) {
   /* Test concrete values. True values are computed in R using the R-package
    * WienR and the function WienerCDF() with its partial derivatives
    */
@@ -390,7 +416,7 @@ TEST(mathPrimCorrectValues, wiener_lcdf) {
     var sv = sv_vec[i];
     var sw = sw_vec[i];
     var st0 = st0_vec[i];
-    var lcdf = stan::math::wiener_lcdf(y, a, t0, w, v, sv, sw, st0);
+    var lcdf = stan::math::wiener_lcdf_defective(y, a, t0, w, v, sv, sw, st0);
     lcdf.grad();
     EXPECT_NEAR(lcdf.val(), true_lcdf[i], err_tol_dens);
     EXPECT_NEAR(y.adj(), true_grad_y[i], err_tol);