Jelly,  12  9 bytes

ṢṚ×J$ṫ⁵<Ṃ

A full program which accepts x T M and prints 0 if the peer is rewarded and 1 if not.

Try it online!

How?

ṢṚ×J$ṫ⁵<Ṃ - Main Link: list of numbers, x; number, T   e.g. [100, 50, 77, 22, 14, 45], 180

Ṣ         - sort x                                          [ 14, 22, 45, 50, 77,100]

 Ṛ        - reverse                                         [100, 77, 50, 45, 22, 14]

    $     - last two links as a monad:

   J      -   range of length                               [  1,  2,  3,  4,  5,  6]

  ×       -   multiply                                      [100,154,150,180,110, 84]

     ṫ    - tail from index:

      ⁵   -   5th argument (3rd input), M   (e.g. M=3)      [        150,180,110, 84]

       <  - less than T?                                    [          1,  0,  1,  1]

        Ṃ - minimum                                         0

05AB1E, 9 bytes

{Rƶ.ssè›ß

Try it online or verify all test cases.

Port of @JonathanAllan's Jelly answer, so also takes the inputs x T M and outputs 0 for "yes" and 1 for "no". If this is not allowed, and it should be inverted, a trailing _ can be added.

Explanation:

{           # Sort the (implicit) input `x`

            #  i.e. `x`=[100,50,77,22,14,45] → [14,22,45,50,77,100]

 R          # Reverse it

            #  i.e. [14,22,45,50,77,100] → [100,77,50,45,22,14]

  ƶ         # Multiply it by it's 1-indexed range

            #  i.e. [100,77,50,45,22,14] → [100,154,150,180,110,84]

   .s       # Get all the suffices of this list

            #  i.e. [100,154,150,180,110,84]

            #   → [[84],[110,84],[180,110,84],[150,180,110,84],[100,154,150,180,110,84]]

     s      # Swap to take the (implicit) input `T`

      è     # Get the prefix at index `T`

            #  i.e. [[84],[110,84],[180,110,84],[150,180,110,84],[100,154,150,180,110,84]]

            #   and `T=3` → [150,180,110,84]

       ›    # Check for each list-value if the (implicit) input `M` is larger than it

            #  i.e. [150,180,110,84] and `M`=180 → [1,0,1,1]

        ß   # And pop and push the minimum value in the list (which is output implicitly)

            #  i.e. [1,0,1,1] → 0

Alternative for .ssè:

sG¦}

Try it online or verify all test cases.

Explanation:

s       # Swap to take the (implicit) input `T`

 G }    # Loop `T-1` times:

  ¦     #  Remove the first item from the list that many times

        #   i.e. [100,154,150,180,110,84] and `T=3` → [150,180,110,84]

C# (Visual C# Interactive Compiler), 83 bytes

(n,x,t,m)=>n>=m&&new int[n-m+1].Where((_,b)=>x.Count(a=>a>=t/(b+m))>=b+m).Count()>0

Short-circuiting AND (&&) is needed, or else if m > n, the array will be initialized with a negative number. Uses a different algorithm than the other existing submissions.

// Takes in 4 parameters as input

(n,x,t,m)=>

// Is n greater than or equal to m?

n>=m

// If it isn't, stop right there and return false. If it is, continue

&&

// Create a new array with the length of all the numbers from m to n, inclusive

new int[n-m+1]

// And filter the results by

.Where((_,b)=>

// If the number of people that invested more than the total amount divided by the index plus m

x.Count(a=>a>=t/(b+m))

// Is greater than the index plus m

>= b+m)

// And check if there is at least one value in the filtered IEnumerable<int>, and if there is, return true

.Count()>0

Try it online!

JavaScript, 54 52 bytes

(x,t,m,n)=>x.sort((a,b)=>a-b).some(i=>i*n-->=t&n>=m)

Try it online

Retina, 79 bytes

d+

*

O^`_+(?=.*])

_+(?=.*])(?<=(W+_+)+)

$#1*$&

+`W+_+(.*_)_$

$1

(_+).*], 1,

Try it online! Takes input in the format [x], T, M. Link includes test cases. Explanation:

d+

*

Convert to unary.

O^`_+(?=.*])

Sort [x] in descending order.

_+(?=.*])(?<=(W+_+)+)

$#1*$&

Multiply each element of [x] by its index.

+`W+_+(.*_)_$

$1

Delete the first M-1 elements of [x].

(_+).*], 1,

Test whether any remaining element of [x] is greater or equal to T.

Perl 6, 46 33 29 bytes

{$^b>all $^a.sort Z*[...] @_}

Try it online!

Anonymous code blocks that takes input in the form list, amount, length of list, minimum amount of investors and returns a truthy/falsey all Junction, where truthy is failed and falsey is success.

Explanation:

{                           }  # Anonymous code block

     all                       # Are all of

         $^a.sort                # The sorted list

                  Z*             # Zip multiplied by

                     [...] @_    # The range from length of list to the minimum amount

 $^b>                          # Not smaller than the given amount?

05AB1E, 6 bytes

Input taken in the order T, N, x, M

Output is 0 for peer reward and 1 if not

Ÿs{*›W

Try it online!
or as a Test Suite

Explanation

Ÿ        # push the range [N ... T]

 s{      # push the list x sorted ascending

   *     # elementwise multiplication (crops to shortest list)

    ›    # for each element, check if M is greater than it

     W   # push min of the result

         # output implicitly

JavaScript, 72 bytes

Code

(x,T,M)=>x.sort(t=(d,e)=>e-d).map((s,i)=>s*i+s).slice(M-1).sort(t)[0]>=T

Try it online!

Accepts input in format (x,T,M)

Explanation

x.sort(t=(d,e)=>e-d)     \sort numbers in reverse numerical order

.map((s,i)=>s*i+s)       \Multiply each number in array by position(1 indexed) in array

.slice(M-1)              \Remove the first M-1 elements (at least M people)

.sort(t)[0]              \Get the maximum value in the array

>=T                      \True if the maximum value is >= the threshold

Python 3, 136 bytes

Just tests the conditions to make sure they are met. 1 if the reward is given, 0 if not.

lambda N,x,T,M:(sum(x)>=T)*(M<=N)*any(any(all(j>=T/k for j in i)for i in combinations(x,k))for k in range(M,N+1))

from itertools import*

Try it online!

Python,  71  65 bytes

lambda x,T,M:all(i*v<T for i,v in enumerate(sorted(x)[-M::-1],M))

Try it online!

An unnamed function; port of my Jelly answer. As such "yes" is False and "no" is True. Here, however, we discard test-cases as a part of the reversal and take advantage of the ability to initiate the enumerate count to M. (min would also work in place of all)

R, 43 42 bytes

-1 bytes by implementing the approach even more closely

function(N,x,S,M)min(sort(x,T)[M:N]*M:N<S)

Try it online!

Simple R implementation of Jonathan's Jelly approach. I tried a bunch of variations but this pips the best I could think of by a few bytes.

1 implies failure, 0 implies success.

C# (.NET Core), 129 bytes

Without LINQ.

(n,q,t,m)=>{int c=0;for(var k=m;k<=q.Length;){for(var j=0;j<q.Length;){if(q[j++]>=t/k)c++;}c=c>=k++?1:0;if(c>0)break;}return c;};

Try it online!

Japt, 16 14 13 11 bytes

ñ í*WõX)d¨V

Try it

ñ í*WõX)d¨V

                  :Implicit input of array U=x and integers V=T, W=M & X=N

ñ                 :Sort U

  í               :Interleave with

    WõX           :  Range [W,X]

   *              :  And reduce each pair of elements by multiplication

       )          :End interleaving

        d         :Any

         ¨V       :  Greater than or equal to V