
<p class="has-drop-cap wp-block-paragraph">Han har bara gjort 21 starter, men skapat många rubriker. I vintras bjöds <strong>San Moteur</strong> (e. Panne de Moteur) som första häst in i Elitloppet om tre veckor. Vägen dit var tänkt att innehålla tre starter, men det blir bara två.<br>Efter enkel seger på hemmabanan Färjestad på långfredagen tvingades Björn Goop stryka sin stjärnhäst från Paraförsöket på Jägersro för två veckor sedan på grund av feber, men som anmäld till försöket öppnades möjligheten till wildcard och på lördagen gör San Moteur ett emotsett framträdande.</p>



<p class="wp-block-paragraph">Och han gör det som världsrekordhållare efter den fenomenala uppvisningen i Jubileumspokalen på Solvalla förra sommaren där han dundrade runt på 1.09,7a/2.140 meter.</p>



<p class="wp-block-paragraph">Björn Goop vet hur man vinner loppet på den forna hemmabanan. 2006 satt han i sulkyn bakom pappa Olle-tränade <strong>Thai Tanic</strong> (e. Viking Kronos) och tio år senare var Fabrice Souloys svenskfödda sto <strong>Your Highness</strong> (e. Chocolatier) segervapnet. Som tränare är andraplatsen med Your Highness året efter största framgången.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/05/pershingolympiatravet-617x333.jpg" alt="" class="wp-image-159998"/><figcaption class="wp-element-caption">Ingemar Stenmark och Linda Haglund flankerar vinnarna Pershing och Berndt Lindstedt i första upplagan av Olympiatravet. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Kärt barn har många namn och lördagens storlopp på Åby, Paralympiatravet, har haft flera under åren. Vid premiären 1979 var namnet Guldmedaljen och loppet var placerat utanför V65-kupongen.</p>



<p class="wp-block-paragraph">Även året efter var det Guldmedaljen som gällde innan det – efter att ha varit inställt 1981 – var premiär för Olympiatravet 1982. 2020 blev det nya namnet Paralympiatravet, sedan det skrivits avtal med Sveriges Paralympiska Kommitté och Parasport.</p>



<p class="wp-block-paragraph">Efter premiäråret på Jägersro var Solvalla arrangör 1980 och 1984 (fyraåringslopp det året) och Åby 1982. Sedan 1985 har Olympiatravet/Paralympiatravet varit bosatt på Åby. Två gånger har Olympiatravet ställts in, 1981 och 1983.</p>



<p class="wp-block-paragraph">1985 började Olympiatravet ta fart när det gällde prispengar. Från 75.000 till 300.000 kronor i förstapris. Torbjörn Jansson triumferade bakom svensk travsports nya superstar <strong>Meadow Road</strong>. Samma år vann han också Elitloppet och båda avdelningarna i Statue of Liberty Trot.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/05/whoswhopaje220507adamstromstalltz-617x412.jpg" alt="" class="wp-image-298929"/><figcaption class="wp-element-caption">Tränaren Pasi Aikio, Who&#8217;s Who och skötaren Jennie Ek efter vinsten i Paralympiatravet. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Förstapriset var 1,5 miljoner kronor åren 2008 till 2019, men 2020 sänktes det till miljonen jämnt i spåren av coronapandemin. Sedan 2021 är den stora prischecken återställd och den summan kvitterade <strong>Who’s Who</strong> (e. Maharajah) ut förra året.</p>



<p class="wp-block-paragraph">Pasi Aikios stjärna har inte startat sedan Elitloppshelgen och finns inte med i årets upplaga. Därmed går han miste om att göra trion <strong>Queen L, Copiad</strong> och <strong>Gidde Palema</strong> sällskap. De är nämligen ensamma om att försvara titeln i Olympia- och Paralympiatravet.</p>



<p class="wp-block-paragraph"><strong>Maharajah</strong> (e. Viking Kronos) och Who’s Who är ändå historiska. Det är första gången en far och son stått som vinnare i storloppet. Pappa Maharajah gjorde när han vann Olympiatravet 2013 på 1.11,0a/2.140 meter tillsammans med Örjan Kihlström och Who’s Who följde upp ifjol – med gemensam ägare, uppfödare och kusk dessutom: Travkompaniet, Menhammar Stuteri och Örjan Kihlström.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Karriärens största seger tog <strong>Milliondollarrhyme</strong> (e. Ready Cash) på just Åbytravet när han hösten 2019 spurtade hem Svenskt Mästerskap tillsammans med sin tränare Fredrik B Larsson. Han har även en andraplats i SM från start på Mölndalsbanan när han nu nio år gammal debuterar i Paralympiatravet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/10/milliondollarrhymemal-617x333.jpg" alt="" class="wp-image-114739"/><figcaption class="wp-element-caption">Milliondollarrhyme och Fredrik B Larsson vid segern i SM 2019. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Den bereste globetrottern har tävlat på 18 svenska banor och dessutom i Frankrike, Italien och Finland. Tre gånger har han testat i Elitloppet med fjärdeplatser i finalen både 2019 och 2020 som bästa resultat. </p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">5 ston har vunnit Olympiatravet. Först ut var <strong>Jana Bloc</strong> 1982 och hon har följts av <strong>Grades Singing</strong> 1987, <strong>Queen L.</strong> 1993, 1994 och sedan dröjde det till <strong>Your Highness</strong> 2016. 2021 sällade sig fransyskan <strong>Delia du Pommereux</strong> (e. Niky) till den skaran och hon startade även ifjol.<br>2023 års upplaga saknar dock ston i startlistan, där sju hingstar och tre valacker gör upp om segern.</p>



<h2 class="wp-block-heading">Startlista Paralympiatravet</h2>



<p class="wp-block-paragraph"><em>För treåriga och äldre hästar, 2.140 meter autostart:</em><br><strong>Pris: </strong>1.500.000-700.000-325.000-150.000-75.000-40.000-30.000-25.000 kr</p>



<ol class="wp-block-list">
<li>Milliondollarrhyme (e. Ready Cash) – Fredrik B Larsson</li>



<li>Chapuy (e. Quite Easy) – Åke Lindblom</li>



<li>Mister Hercules (e. Trixton) – Örjan Kihlström (Daniel Redén)</li>



<li>Cicero T.G. (e. Kadabra) – Magnus Teien Gundersen (Geir Vegard Gundersen)</li>



<li>Rackham (e. Love You) – Christoffer Eriksson</li>



<li>San Moteur (e. Panne de Moteur) – Björn Goop</li>



<li>Hades de Vandel (e. Ganymede) – Robin Bakker (Paul Hagoort)</li>



<li>Emoji (e. Broad Bahn) – Flemming Jensen</li>



<li>Jimmy Ferro B.R. (e. Love You) – Alessandro Gocciadoro</li>



<li>Bilo Jepson (e. Timoko) – Carl Johan Jepson (Vitale Ciotola)</li>
</ol>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/04/chapuyheat0-617x333.jpg" alt="" class="wp-image-157334"/><figcaption class="wp-element-caption">Åke Lindbloms Chapuy. Foto Jeannie Karlsson/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">I början av augusti 2016 – som tvååring – debuterade <strong>Chapuy</strong> (e. Quite Easy) på hemmabanan Örebro tillsammans med sin tränare Åke Lindblom.</p>



<p class="wp-block-paragraph">När han nu fyllt nio år och är inne på sin åttonde säsong på tävlingsbanan – 82 starter (20-13-12) – ställs valacken inför sin största uppgift hittills. Den startsnabbe valacken har tagit 17 av sina 20 segrar över sprinterdistans, däribland triumfen i ”Sista chansen” förra helgen”, men i mars vann han gulddivisionen i Örebro över just medeldistans.<br>Det är en av tre guldsegrar bara i år, där Chapuy dessutom kan räkna in andraplatsen bakom <strong>Aetos Kronos</strong> (e. Bild Eagle) i guldfinalen på Solvalla i mars, där han plockade livets största prischeck: 250.000 kronor.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/11/misterhercules-617x333.jpg" alt="" class="wp-image-120446"/><figcaption class="wp-element-caption">Mister Hercules och Örjan Kihlström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Daniel Redén har en tränarseger i loppet, då norske <strong>Lionel</strong> (e. Look de Star) segrade 2017. Nu mönstrar han nybakade Grupp I-vinnaren <strong>Mister Hercules</strong> (e. Trixton), som spräckte en lång svit för svenska travare utomlands. När han tog hem Seinäjoki Race var det den första svenskfödda, svensktränade Grupp I-vinnaren på två år då <strong>Dear Friend</strong> (e. Orlando Vici) segrade i samma lopp 2021.</p>



<p class="wp-block-paragraph">Själv lade Mister Hercules beslag på sin första stora titel på hösten som treåring när han vann Breeders Crown-finalen för hingstar och valacker.</p>



<p class="wp-block-paragraph">På lördagens finalbana har han gjort två framträdanden, båda som fyraåring. Först missade han som fyra finalplats i Kungapokalen och sedan på hösten tog han tredjeplatsen i Europaderbyt Grand Prix de l’U.E.T. som vanns av <strong>Calgary Games</strong> (e. Readly Express). I den finalen gjorde en viss <strong>San Moteur</strong> bort sig med galopp och diskvalificerades.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/09/rackhamheat-617x333.jpg" alt="" class="wp-image-109324"/><figcaption class="wp-element-caption">Christoffer Eriksson och Rackham. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Christoffer Erikssons fux <strong>Rackham</strong> (e. Love You) har i stora drag gjort sin klassresa i travsporten genom STL-lopp, även om han kvalade in till Breeders Crown-finalen som fyraåring (oplacerad). Hela 21 av livets 50 starter har gjorts i rikstotosammanhang, där han debuterade på just Åby Pokalfinaldagen i maj 2020 med att vinna ett klass II-försök över för klassen ovanliga 3.140 meter.</p>



<p class="wp-block-paragraph">I bronsdivisionen kom första segern i finalen på sensommaren året efter och av bara farten plockade Rackham hem silverdebuten tre veckor senare. I andra försöket i gulddivisionen i Halmstad i somras togs första segern i högsta klassen.</p>



<p class="wp-block-paragraph">Platsen i Paralympiatravet tog han av egen kraft genom att vinna det första uttagningsloppet, Algot Scotts Minne på Åby för fem veckor sedan.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">S<strong>ugarcane Hanovers</strong> triumf 1988 är fortfarande för många det största ögonblicket i loppets historia när han vann i överlägsen stil för Gunnar Eggen och utklassade världsmästaren <strong>Callit</strong>. Sugarcane Hanover värmde dåligt, men gjorde sina motståndare till statister när det blev allvar.<br>Han svepte runt sina konkurrenter till spets redan innan sista kurvan och vann på 1.14,4a/2.140 meter, medan Callit noterade 1.15,6 som tvåa – akterseglad med ”många längder.”</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/05/sugarcanehanoverdef2-617x333.jpg" alt="" class="wp-image-160002"/><figcaption class="wp-element-caption">Sugercane Hanover, Gunnar Eggen och skötaren Morten Waage segerdefilerar efter uppvisningen i Olympiatravet 1988. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Gunnar Eggen är inte ensam norrman att ha vunnit. Göran Antonsen satt upp bakom ögonstenen <strong>Lionel</strong> (e. Look de Star) – i träning hos Daniel Redén – och blåste runt alla konkurrenter till seger 2017.</p>



<p class="wp-block-paragraph">Det kan bli norskt även i årets upplaga när de röd-blå-vita färgerna försvaras av far och son Gundersen. Pappa Geir Vegard tränar och Magnus kör sexårige <strong>Cicero G.T.</strong> (e. Kadabra), som vann norska Derbyt 2021.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Andraplatser har det blivit som bäst för danska tränare i loppet. Steen Juul körde Peter Rasmussen-tränade <strong>Atom Tess</strong> (e. Smokin Yankee) till andraplatsen bakom <strong>Etain Royal</strong> (e. Ulf d’Ombree) 2001 och ifjol överlät han tömmarna till Björn Goop bakom egentränade stjärnan <strong>Extreme</strong> (e. Chocolatier), som tog silvermedaljen bakom <strong>Who’s Who</strong> (e. Maharajah).</p>



<p class="wp-block-paragraph">Det danska bidraget i år signeras Flemming Jensen, som via segern i uttagningsloppet på Jägersro kvalade in sjuårige segermaskinen <strong>Emoji</strong> (e. Broad Bahn). Det var hästens 25:e seger på 53 försök.</p>



<p class="wp-block-paragraph">En danskfödd travare har vunnit Olympiatravet. I regn och rusk var Tommy Strandqvist-tränade <strong>Rival Damkaer</strong> (e. Cooperfield) vassast tillsammans med Erik Adielsson i 1998 års upplaga. Segertiden 1.16,2a/2.140 meter var den långsammaste sedan 1982, då loppet dessutom avgjordes med voltstart.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/bilo3-1-617x393.jpg" alt="" class="wp-image-360478"/><figcaption class="wp-element-caption">Bilo Jepson vid seger på Vincennes i september. På lördag startar hästen i Paralympiatravet och det sker med en svensk istället för fransk mark kusk som det först var tänkt. Foto: Gerard Forni</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">En fransos tränad i Nederländerna. En tysk tränad i Italien. En italienare tränad i Frankrike av en italienare. De internationella inslagen är – just det – internationella. </p>



<ul class="wp-block-list">
<li>Paul Hagoorts sexåring <strong>Hades de Vandel</strong> (född i Frankrike e. Ganymede) tog till till Paralympiatravet av egen kraft genom att svara för en svettig insats i försöket på Axevalla.</li>



<li>Alessandro Gocciadoros femåring <strong>Jimmy Ferro B.R.</strong> (född i Tyskland e. Love You) är yngst i fältet och fick inbjudan efter att ha vunnit Prins Carl Philips Julileumspokal på Färjestad på långfredagen på topptiden 1.09,5a/1.640 meter.</li>



<li>Vitale Ciotolas sexåring <strong>Bilo Jepson</strong> (född i Italien e. Timoko) avslutade förra året med att vinna två Grupp III-lopp på Vincennes i form av Prix Emile Beziere (€90.000) och Prix Oscar Collard (€80.000).</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/04/ringostarrtrebml-1-617x309.jpg" alt="" class="wp-image-22312"/><figcaption class="wp-element-caption">Ringostarr Treb med spetsade öron över mållinjen i Olympiatravets final 2018. Foto Mia Törnberg</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Paralympiatravet är det riktiga startskottet för storloppssäsongen för den äldre eliten i Sverige och om drygt tre veckor stundar Elitloppet på Solvalla. Att vinna Åbys storlopp och sedan fortsätta med att plocka hem Elitloppet några veckor senare har åtta hästar lyckats med.</p>



<ul class="wp-block-list">
<li>1979 – <strong>Pershing</strong> (e. Nevele Pride) – Berndt Lindstedt</li>



<li>1985 – <strong>Meadow Road</strong> (e. Madison Avenue) – Torbjörn Jansson</li>



<li>1995 – <strong>Copiad</strong> (e. Texas) – Erik Berglöf</li>



<li>2002 – <strong>Varenne</strong> (e. Waikiki Beach) – Giampaolo Minnucci (Jori Turja)</li>



<li>2004 – <strong>Gidde Palema</strong> (e. Alf Palema) – Åke Svanstedt</li>



<li>2011 – <strong>Brioni</strong> (e. Timberland) – Joakim Lövgren</li>



<li>2012 – <strong>Commander Crowe</strong> (e. Juliano Star) – Christophe Martens (Fabrice Souloy)</li>



<li>2018 – <strong>Ringostarr Treb</strong> (e. Classic Photo) – Wim Paal (Jerry Riordan)</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">2 avelshingstar har fyra vinnare vardera i Olympiatravet/Paralympiatravet. Texas var först till fyra med <strong>Grades Singing</strong> 1987, <strong>Karate Chop</strong> 1991 och <strong>Copiad</strong> 1995, 1996.<br>Alf Palema fördelade sina fyra vinster på två avkommor; <strong>Gidde Palema</strong> 2003, 2004, 2005 och <strong>Torvald Palema</strong> 2008.</p>



<p class="wp-block-paragraph">Tre vinnare i Olympiatravet har Viking Kronos: <strong>Thai Tanic</strong> 2006, <strong>Triton Sund</strong> 2009 och <strong>Maharajah</strong> 2013.<br>Trion Crowntron, Super Play och Waikiki Beach står med två vinnare vardera: Queen L. (1993, 1994), <strong>Scandal Play</strong> (1997, 1999) och <strong>Varenne</strong> (2000, 2002).</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Alla deltagare i Paralympiatravet kommer att vara uppstallade i övervakningsstall inför loppet, detta i enlighet med paragraf 5 i Antidopningsreglementet. Det innebär att startande hästar i loppet måste vara på plats i anvisat stall klockan 08.00-10.00 på lördagen.</p>



<p class="wp-block-paragraph"><em>”2020 var första året då övervakningsstall kunde användas under svenska tävlingsdagar i enlighet med Antidopningsreglementet. Det främsta syftet med införandet av övervakningsstall under tävlingar är att öka kontrollen av såväl hästar som utrustning. Genom den ökade säkerheten kan vi arbeta både mot att ingen utomstående kan ta kontakt med de hästar som är uppstallade i övervakningsstallet och att de inte tillförs något, preparat eller annat, som kan påverka prestationen på banan,” </em>skriver Svensk Travsport på sin hemsida.</p>



<p class="wp-block-paragraph"></p>


<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Alla vinnare av Paralympiatravet								</h3>
<div class="content">
<p class="wp-block-paragraph"><em>År, vinnare – Kusk (tränare) – Segertid – Förstapris (kr)</em><br />1979 <strong>Pershing</strong> – Berndt Lindstedt – 1.17,9a/2.100 – 60.000<br />1980 <strong>Don Ego</strong> – Stig H Johansson – 1.18,4/2.140 – 40.000<br />1981 Inställt<br />1982 <strong>Jana Bloc</strong> – Ove R Andersson – 1.18,8/2.140 – 40.000<br />1983 Inställt<br />1984 <strong>Einarsin</strong> – Tapio Perttunen – 1.15,1a/2.140 – 75.000<br />1985 <strong>Meadow Road</strong> – Torbjörn Jansson – 1.15,5a/2.140 – 300.000<br />1986 <strong>Utah Bulwark</strong> – Stig H Johansson – 1.14,5a/2.140 – 300.000<br />1987 <strong>Grades Singing</strong> – Ulf Thoresen (Herve Filion) – 1.15,4a/2.140 – 300.000<br />1988 <strong>Sugarcane Hanover</strong> – Gunnar Eggen – 1.14,4a/2.140 – 400.000<br />1989 <strong>Callit</strong> – Karl O Johansson – 1.14,9a/2.140 – 400.000<br />1990 <strong>Jet Ribb</strong> – Hans G Eriksson – 1.14,6a/2.140 – 500.000<br />1991 <strong>Karate Chop</strong> – Bo Näslund – 1.15,1a/2.140 – 500.000<br />1992 <strong>Bravo Sund</strong> – Jorma Kontio (Veijo Heiskanen) – 1.14,3a/2.140 – 500.000<br />1993 <strong>Queen L.</strong> – Stig H Johansson – 1.14,3a/2.140 – 500.000<br />1994 <strong>Queen L.</strong> – Stig H Johansson – 1.13,8a/2.140 – 500.000<br />1995 <strong>Copiad</strong> – Erik Berglöf – 1.13,6a/2.140 – 500.000<br />1996 <strong>Copiad</strong> – Erik Berglöf – 1.13,9a/2.140 – 800.000<br />1997 <strong>Scandal Play</strong> – Bo Eklöf (Lars Marklund)– 1.13,7a/2.140 – 800.000<br />1998 <strong>Rival Damkaer</strong> – Erik Adielsson (Tommy Strandqvist) – 1.16,2a/2.140 – 800.000<br />1999 <strong>Scandal Play</strong> – Bo Eklöf (Lars Marklund) – 1.14,8a/2.140 – 800.000<br />2000 <strong>Varenne</strong> – Giampaolo Minnucci (Jori Turja) – 1.12,7a/2.140 – 800.000<br />2001 <strong>Etain Royal</strong> – Jorma Kontio (Pirjo Vauhkonen) – 1.13,2a/2.140 – 800.000<br />2002 <strong>Varenne</strong> – Giampaolo Minnucci (Jori Turja) – 1.12,4a/2.140 – 800.000<br />2003 <strong>Gidde Palema</strong> – Åke Svanstedt – 1.13,1a/2.140 – 800.000<br />2004 <strong>Gidde Palema</strong> – Åke Svanstedt – 1.12,9a/2.140 – 800.000<br />2005 <strong>Gidde Palema</strong> – Åke Svanstedt – 1.12,9a/2.140 – 800.000<br />2006 <strong>Thai Tanic</strong> – Björn Goop (Olle Goop) – 1.13,0a/2.140 – 1.000.000<br />2007 <strong>Gentleman</strong> – Thomas Uhrberg (Kari Lähdekorpi) – 1.12,8a/2.140 – 1.000.000<br />2008 <strong>Torvald Palema</strong> – Åke Svanstedt – 1.12,2a/2.140 – 1.500.000<br />2009 <strong>Triton Sund</strong> – Örjan Kihlström (Stefan Hultman) – 1.11,1a/2.140 – 1.500.000<br />2010 <strong>Copper Beech</strong> – Conrad Lugauer – 1.11,6a/2.140 – 1.500.000<br />2011 <strong>Brioni</strong> – Joakim Lövgren – 1.11,4a/2.140 – 1.500.000<br />2012 <strong>Commander Crowe</strong> – Christophe Martens (Fabrice Souloy) – 1.12,2a/2.140 – 1.500.000<br />2013 <strong>Maharajah</strong> – Örjan Kihlström (Stefan Hultman) – 1.11,0a/2.140 – 1.500.000<br />2014 <strong>Solvato</strong> – Veijo Heiskanen – 1.10,9a/2.140 – 1.500.000<br />2015 <strong>B.B.S.Sugarlight</strong> – Peter Untersteiner (Fredrik Solberg) – 1.10,7a/2.140 – 1.500.000<br />2016 <strong>Your Highness</strong> – Björn Goop (Fabrice Souloy) – 1.10,9a/2.140 – 1.500.000<br />2017 <strong>Lionel</strong> – Göran Antonsen (Daniel Redén) – 1.10,9a/2.140 – 1.500.000<br />2018 <strong>Ringostarr Treb</strong> – Wim Paal (Jerry Riordan) – 1.10,0a/2.140 – 1.500.000<br />2019 <strong>Handsome Brad</strong> – Carl Johan Jepson (Ulf Stenströmer) – 1.11,0a/2.140 – 1.500.000<br />2020 <strong>Elian Web</strong> – Jorma Kontio (Katja Melkko) – 1.12,2a/2.140 – 1.000.000<br />2021 <strong>Delia du Pommereux</strong> – Eric Raffin (Sylvain Roger) – 1.10,9a/2.140 – 1.500.000<br />2022 <strong>Who&#8217;s Who</strong> – Örjan Kihlström (Pasi Aikio) – 1.11,9a/2.140 meter – 1.500.000<br />2023 <strong>San Moteur</strong> – Björn Goop – 1.10,8a/2.140 – 1.500.000<br />2024 <strong>Önas Prince</strong> – Per Nordström – 1.10,1a/2.140 meter – 1.500.000<br />2025 <strong>Borups Victory</strong> – Daniel Wäjersten – 1.10,0a/2.140 meter – 1.500.000</p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
