Pip, 50 42 38 bytes

T$<(MN{_NaM"lcowbe"}//^2M[aYa@<i])++iy

Pass the string in as a command-line argument, quoted if necessary. Try it online!

Explanation

I'm going to explain this in two parts: the cowbell function and the full program. First, here's the function that computes the amount of cowbell in a string:

MN{_NaM"lcowbe"}//^2

{...} defines a function. Many Pip operators, when applied to a function, return another function; for example, -{a+1} is the same as {-(a+1)}. So the above is equivalent to

{MN(_NaM"lcowbe")//^2}

which works as follows:

{                    }  Function, in which a is the 1st argument (the string)
    _Na                 Lambda fn: returns number of times its argument occurs in a
       M"lcowbe"        Map that function to the characters of "lcowbe"
                   ^2   A devious way to get [2]: split the scalar 2 into characters
   (            )//     Int-divide the list of character counts by [2]
                        Since the lists are not the same length, this divides the first
                          element (# of l's) by 2 and leaves the others alone
 MN                     Take the min of the resulting list

Now that we have that, here's the full program:

T$<(MN{_NaM"lcowbe"}//^2M[aYa@<i])++iy
                                        a is 1st cmdline arg, i is 0 (implicit)
T                                       Loop till condition is true:
                            a@<i        Slice leftmost i characters of a
                           Y            Yank that into y variable
                         [a     ]       List containing a and that value
                        M               To that list, map...
    MN{_NaM"lcowbe"}//^2                ... the cowbell function
                                        Result: a list containing the amount of cowbell
                                        in the original string and the amount in the slice
 $<(                             )      Fold on less-than: true if the first element is
                                        less than the second, otherwise false
                                  ++i   In the loop, increment i
                                     y  Once the loop exits, print y (the latest slice)

Bash, 184 bytes

f()(tr -cd cowbel<<<"$1"|sed 's/\(.\)/\1\
/g'|sort|uniq -c|awk '{print int($1/(($2=="l")?2:1))}'|sort -n|head -1)
for((m=1;`f "$1${1:0:m}"`!=$[`f "$1"`+1];m++)){ :;}
echo "$1${1:0:$m}"

Try it online!

Thanks to @AlbertRenshaw for golfing 2 bytes off.

C, 511 488 474 470

void f(char*a){char*s;int i=-1,c,o,w,b,e=b=w=o=c,l=3,n,r,z=i,y=0;for(;s=a[++i];c+=s==99,o+=s=='o',w+=s=='w',b+=s==98,e+=s=='e',l+=s=='l');r=~-l/2;n=c<o?c:o;n=w<n?w:n;n=b<n?b:n;n=e<n?e:n;n=r<n?r:n;c=c==n;o=o==n;w=w==n;b=b==n;e=e==n;if(r==n){if(!(l%2)){l=1;c=o=w=b=e=0;}else{l=2;}}else{l=1+l%2;}n=c+o+w+b+e+l;for(printf("%s",a);s=n?a[++z]:0;s==99&&c?n--,c--:0,s=='o'&&o?n--,o--:0,s=='w'&&w?n--,w--:0,s==98&&b?n--,b--:0,s=='e'&&e?n--,e--:0,s=='l'&&l?n--,l--:0,putchar(s));}

Try it online

Readable format:

void f(char*a){

char*s;

int i=-1,c,o,w,b,e=b=w=o=c,l=3,n,r,z=i,y=0;

for(;s=a[++i];c+=s==99,o+=s=='o',w+=s=='w',b+=s==98,e+=s=='e',l+=s=='l');

r=~-l/2;

n=c<o?c:o;n=w<n?w:n;n=b<n?b:n;n=e<n?e:n;n=r<n?r:n;

c=c==n;o=o==n;w=w==n;b=b==n;e=e==n;

if(r==n){
    if(!(l%2)){
        l=1;c=o=w=b=e=0;
    }else{
        l=2;
    }
}else{
    l=1+l%2;
}

n=c+o+w+b+e+l;

for(printf("%s",a);s=n?a[++z]:0;s==99&&c?n--,c--:0,s=='o'&&o?n--,o--:0,s=='w'&&w?n--,w--:0,s==98&&b?n--,b--:0,s=='e'&&e?n--,e--:0,s=='l'&&l?n--,l--:0,putchar(s));}

Python 2, 125 bytes

n=lambda s:min([s.count(c)/(1+a/5)for a,c in enumerate("cowbel")])
def f(s,i=0):
 while n(s)==n(s+s[:i]):i+=1
 return s+s[:i]

n counts the number of cowbells

Perl 6, 91 bytes

{my &c={.comb.Bag.&{|.<c o w b e>,.<l>div 2}.min}
first *.&c>.&c,($_ X~[\,](.comb)».join)}

How it works

Inside the lambda, another lambda for counting the number of cowbells in a string is defines as such:

my &c={                                        }  # Lambda, assigned to a variable.
       .comb                                      # Split the string into characters.
            .Bag                                  # Create a Bag (maps items to counts).
                .&{                       }       # Transform it into:
                   |.<c o w b e>,                 #   The counts of those letters, and
                                 .<l>div 2        #   half the count of "l" rounded down.
                                           .min   # Take the minimum count.

The rest of the code uses this inner lambda &c to find the result, like this:

                     [\,](.comb)».join   # All prefixes of the input,
               ($_ X~                 )  # each appended to the input.
first         ,                          # Return the first one for which:
      *.&c>                              #   The cowbell count is greater than
           .&c                           #   the cowbell count of the input.