Jelly, 12 bytes

ṢṖḊȯ⁸ÆmḤ+.ḞH

A monadic Link accepting a list of numbers which yields a number.

Try it online!

How?

ṢṖḊȯ⁸ÆmḤ+.ḞH - Link, list of numbers, X

Ṣ            - sort X

 Ṗ           - remove the right-most

  Ḋ          - remove the left-most

    ⁸        - chain's left argument, X

   ȯ         - logical OR (if we have nothing left use X instead)

     Æm      - arithmetic mean

       Ḥ     - double

         .   - literal half

        +    - add

          Ḟ  - floor

           H - halve

EDIT: This answer has since become invalid. It was valid for about half a minute after it was posted.

Jelly, 10 bytes

ṢḊṖȯƊÆmḤḞH

Try it online!

Brachylog, 19 bytes

o{bṀk|}⟨+/l⟩×₄<÷₂/₂

Try it online!

And I thought the rounding was awkward in Jelly!

JavaScript (V8), 211 bytes

^{Edit: -2 bytes because I ended with ;n} when I could just end with a }, silly mistake.}

a=>{l=_=>a.length

s=i=>a.splice(i,1)

e=_=>a.reduce((t,i)=>t+=i)/l()

g=_=>(a.sort((x,y)=>x-y),s(0),s(-1),e())

t=n=>Math.floor(n)

r=n=>(m=n%1,m<0.75?(m>0.25?t(n)+0.5:t(n)):Math.ceil(n))

return l()>2?r(g()):r(e())}

Try it online!

I'm sure it can be improved as I'm fairly new, but it was fun to solve this one. I believe the main things that could be improved are my rounding logic/methods, and the fact that the main function uses a function body ({ } and return).

There was one thing in the question that was inconsistent with the examples and I wasn't really sure how to handle it. I implemented it so that it's consistent with the examples, but it doesn't exactly reflect the specified rounding rules, here is the example I found to be inconsistent:

6.5, 9 -> 8

You say it should be 8, although the average is 7.75. In the rounding rules you say it has to be at least .76 to go +1. I chose to reflect the examples instead of your rounding rules, so >=0.75 to go +1, and <=0.25 to go -1, between 0.25 and 0.75 (exclusive) for .5.

Slightly ungolfed with explanation:

a => { // a is the input array

    l = _=>a.length; // shortcut to get arr length

    s = i=>a.splice(i, 1); // shortcut to splice i

    e = _=>a.reduce((t, i) => t += i) / l(); // get array avg

    g = _=>(a.sort((x,y)=>x-y), s(0), s(-1), e()); // what to execute when > 2: sort, remove 1st/last, get avg

    t = n=>Math.floor(n); // Math.floor shortcut

    // apply olympic rounding to number by checking the value of n%1

    r = n=>(m=n%1,m < 0.75 ? (m > 0.25 ? t(n) + 0.5 : t(n)) : Math.ceil(n));

    return l() > 2 ? r(g()) : r(e());

}

Swift, 203 bytes

func a(b:[Double])->Void{var r=0.0,h=0.0,l=11.0

b.forEach{(c)in h=c>h ?c:h;l=c<l ?c:l;r+=c}

var d=Double(b.count)

r=d>2 ?(r-h-l)/(d-2.0):r/d

d=Double(Int(r))

r=r-d<=0.25 ?d:r-d<=0.75 ?d+0.5:d+1

print(r)}

Try it online!

J, ³⁶ 35 bytes

[:(1r4<.@+&.+:+/%#)}:@}.^:(2<#)@/:~

Try it online!

Borrowed the double / floor / halve trick for rounding to 0.5 increments from Unrelated String.

Retina, 86 bytes

.5

__

d+

*4*__

O`_+

_+ (.+) _+

$1

O`.

^ *

$.&*__:

(_+):(1{4})*(11)?_*

$#2$#3*$(.5

Try it online! Link includes test cases. Explanation:

.5

__

d+

*4*__

Since Retina can't readily handle fractional or zero numbers, each number is represented in unary as 1 more than 4 times the value. The .5 therefore expands to 2 _s, while the *4*_ applies to the whole number part, and a final _ is suffixed.

O`_+

Sort the numbers into order.

_+ (.+) _+

$1

If there are at least three numbers, discard the first (smallest) and last (largest).

O`.

Sort the spaces to the start, thus also summing the numbers.

^ *

$.&*__:

Count the number of spaces and add _ and a separator. This then represents the number we have to divide by.

(_+):(1{4})*(11)?_*

$#2$#3*$(.5

Divide the sum by the number of numbers, allowing for the fact that we're working in multiples of 4 times the original number, so that the integer and decimal portions can be directly extracted. This is a truncating division, but fortunately because we added an extra _ to each number, the result effectively includes an extra 0.25, thus giving us the rounding we want.

PHP, 110 bytes

Seems like PHP has some good built-in functions for this. I just array_sum the whole thing, then if there's more than two elements, subtract the min() and max() values and divide by 2 less than the length of the array.

For the rounding, I use the round() function with the PHP_ROUND_HALF_DOWN flag (which = 2) on double the average, and then divide it by 2 so it goes in increments of 0.5

EDIT: for the case of [6.5, 9] I'm following the stated rule that 7.75 rounds to 7.5 and not 8 like in the original example given.

function s($s){$c=count($s);$t=array_sum($s);if($c>2){$c-=2;$t-=min($s)+max($s);}return round($t/$c*2,0,2)/2;}

Try it online!