
<p class="has-drop-cap">En kvartett toppar statistiken över flest tränarsegrar i historiken bakom Drottning Silvias Pokal – och efter lördagen kan det vara en tränare ensam i topp. Stig H Johansson, Petri Puro, Åke Svanstedt och Roger Walmann har vunnit loppet tre gånger. Dubbla triumfer har Robert Bergh, Olle Goop, Björn Larsson och Bo Näslund.</p>



<p>Roger Walmann kan kliva upp i ensam ledning när han har ett starkt kort i <strong>S.G.Empress</strong> (e. Readly Express), som vann korta E3 förra året och totalt nio av 13 starter. I år har dottern till flerfaldiga miljonärskan Riva del Sole vunnit samtliga tre starter.<br>– En komplett travare, snabb, stark och speedig. Det var moderat tempo och hon kändes stark in i mål. Tussarna satt kvar, sade Örjan Kihlström efter försöksvinsten.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/9s.g.empress-617x333.jpg" alt="" class="wp-image-655217"/><figcaption class="wp-element-caption">S.G.Empress vinner BC-semi för Örjan Kihlström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>S.G.Empress mor <strong>Riva del Sole</strong> (e. Gentle Star) 1.11,5ak/3.716.024 kr var en mycket framgångsrik tävlingshäst som vann 22 av 64 starter under den karriär hon oavbrutet tillbringade hos Årjängstränaren Tom Horpestad.<br>I Sverige var hennes största seger 2006 års upplaga av Sto SM. Året efter vann hon därtill tre lopp på Vincennes i form av Prix de Rouen (€100.000), Prix Helen Johansson (€80.000) och Prix de la Lorraine (€65.000) innan hon kom tillbaka till Sverige och tog hem Lady Snärts lopp under Elitloppshelgen.</p>



<h2 class="wp-block-heading">Startlista Drottning Silvias Pokal</h2>



<p>Åby lördag 3 maj, förstapris 1.000.000 kr<br>2.140 meter autostart:<br><em>Hästnamn (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Scarfo Pellini (e. Walner) – Björn Goop</li>



<li>Vivillion (e. Propulsion) – Daniel Wäjersten</li>



<li>S.G. Empress (e. Readly Express) – Örjan Kihlström (Roger Walmann)</li>



<li>Matchmadeinheaven (e. S.J.’s Caviar) – Carl Johan Jepson (Fredrik Wallin)</li>



<li>Mellby Maleficent (e. Propulsion) – Rikard N Skoglund (Daniel Redén)</li>



<li>Kinky Rain (e. Muscle Hill) – Johan Untersteiner</li>



<li>Pretty Be Linda (e. Varenne) – Per Lennartsson (Ola Åsebö)</li>



<li>Panthere d’Inverne (e. Brillantissime) – André Eklundh</li>



<li>J.H. Ellen (e. Winter Harbor) – Stefan Persson (Björn Goop)</li>



<li>O’Hara Boko (e. Robert Bi) – Robin Bakker (Paul Hagoort)</li>



<li>Elegance Silvio (e. Maharajah) – Peter Untersteiner (Johan Untersteiner)</li>



<li>Arctic Angel (e. Face Time Bourbon) – Magnus Teien Gundersen (Geir Vegard Gundersen)</li>
</ol>



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



<p class="has-drop-cap">Att vinna Svenskt Trav-Oaks på hösten som treåring och följa upp med vinst i Drottning Silvias Pokal cirka sju månader senare är det faktiskt bara fyra hästar som har lyckats med i historien. Daniel Wäjersten står inför uppgiften att utöka summan till fem med finskägda toppstoet <strong>Vivillion</strong> (e. Propulsion). </p>



<p>I höstas vann hon Oaks efter ledning från start till mål, men vägen till Drottningpokalens final fick tas via anfall från fjärde utvändigt på sista bortre långsidan.<br>– Hästen kändes jättefin, men det var långt fram 900 kvar och då kändes det sisådär med tanke på open stretch och att det brukar gå snabbt till slut. Men hon gjorde det precis så bra som jag hoppats på, sade Daniel Wäjersten efter försöksvinsten.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/10vivillion3-617x333.jpg" alt="" class="wp-image-645599"/><figcaption class="wp-element-caption">Vivillion vid segern i Svenskt Trav-Oaks 2024. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p><strong>Ston som vunnit Oaks och Drottningpokalen:</strong><br><em>Häst (far) – År – Tränare</em></p>



<ul class="wp-block-list">
<li><strong>Simb Capi</strong> (e. Probe) – 1997-1998 – Lennart Wikström</li>



<li><strong>Giant Diablo</strong> (e. Supergill) – 2003-2004 – Roger Walmann</li>



<li><strong>Tamla Celeber</strong> (e. Cantab Hall) – 2010-2011 – Roger Walmann</li>



<li><strong>Diana Zet</strong> (e. Hard Livin) – 2019-2020 – Daniel Redén</li>
</ul>



<p>Två drottningar valde att möta hingstarna på hösten som treåringar och vann Svenskt Travkriterium innan det blev vinst i Drottning Silvias Pokal året efter. Kjell P Dahlströms<strong> Ina Scot</strong> (e. Allen Hanover) svarade för den bedriften 1992-1993, medan Robert Berghs <strong>Hilda Zonett</strong> (e. Spotlite Lobell) upprepade bravaden 2000-2001.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/ingainheavenwallin2-617x333.jpg" alt="" class="wp-image-513466"/><figcaption class="wp-element-caption">Fredrik Wallin tillsammans med Matchmadeinheavens mamma Inga In Heaven. Foto Jeannie Karlsson/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Ytterligare tre av tränarna bakom finalhästarna vet hur det känns att vinna Drottning Silvias Pokal. Fredrik Wallins toppsto <strong>Activated</strong> (e. Jocose) segrade i 2019 års upplaga, 2020 blev Daniel Redén-tränade <strong>Diana Zet</strong> (e. Hard Livin) drottning på Åby och 2022 triumferade Paul Hagoort-tränade <strong>Chebba Mil</strong> (e. Readly Express).</p>



<p>Wallin ställer i år hoppet till <strong>Matchmadeinheaven</strong> (e. S.J.’s Caviar), som visade framfötterna rejält redan som tvååring när hon vann Svampen. Ifjol tog hon hem E3-chansen och försök till Svenskt Trav-Oaks och i uttagningsloppet till Drottningpokalen blev det ny vinst.<br>Fredrik Wallin är uppfödare och delägare i hästen, som är mamma <strong>Inga In Heavens</strong> (e. Orlando Vici), 1.11,2am/2.237.465 kr, första avkomma. Inga In Heaven slutade tvåa i Drottning Silvias Pokal och kvalade även in till Stochampionatet. Hon tävlade även framgångsrikt på Vincennes.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/mellbymaleficent1-617x333.jpg" alt="" class="wp-image-714006"/><figcaption class="wp-element-caption">Mellby Maleficent på våren som treåring. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Daniel Redéns finalist är Mellby Gårds uppfödning <strong>Mellby Maleficent</strong> (e. Propulsion), som också ägs av Rune Anderssons Mellby Gård. Förhoppningarna var höga på stoet inför treåringssäsongen, men det stannade vid en seger på tio försök. I år har det blivit två andraplatser på tre starter, däribland i försöket till Drottningens där hon sånär nådde ikapp och förbi ledande <strong>Scarfo Pellini</strong> (e. Walner).<br>– Hon var riktigt bra senast, det var riktigt nära att hon vann, hon var ju förbi alldeles efter mål. Hon är på den utvecklingskurvan som jag har hoppats och alltid trott. Nu möter hon hårt motstånd men det är bra för hennes rutin och så hon får skaffa sig hårdhet för jag har alltid hävdat att det hon kan hävda sig i de här sammanhangen, säger Daniel Redén till Stall Zets hemsida.</p>



<p>Paul Hagoorts chans till en andra titel kommer genom svenskfödda <strong>O’Hara Boko</strong> (e. Robert Bi), som vann tvååringsfinalen i Breeders Course på Jägersro.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/05/img6108-617x435.jpg" alt="" class="wp-image-308139"/><figcaption class="wp-element-caption">Scarfo Pellini (e. Walner) var dyrast på Elitauktionen år 2022. Foto: stalltz.se</figcaption></figure>



<p class="has-drop-cap">Tolv finalister, men bara två som bytt ägare på auktion. Björn Goop-tränade <strong>Scarfo Pellini</strong> (e. Walner) ropades in för 1,8 miljoner kronor på Elitauktionen för tre år sedan av Oscar Berglund för Hjelte Restaurang AB i Karlstads räkning. Scarfo Pellini blev då den dyraste ettåringen som sålts på Elitauktionen.<br>Hon gick i träning till Björn Goop efter sommaren som ettåring och var finalist i båda E3-finalerna förra året. I försöket till Drottningpokalen tog hon karriärens tredje seger på 13 försök. </p>



<p>André Eklundh-tränade <strong>Panthere d’Inverne</strong> (e. Brillantissime) var trea bakom Scarfo Pellini och är det andra stoet som såldes på auktion som unghäst. André ropade in henne för 100.000 kronor på Kriterieauktionen.</p>



<p>Panthere d’Inverne avslutade fjolåret med två segrar och ett andrapris och har inlett fyraåringssäsongen på samma fina sätt.</p>



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



<p class="has-drop-cap">Örjan Kihlström och Johnny Takter har flest kusksegrar i Drottninghistorien och båda ståtar med fem triumfer vardera. Totalt har Örjan, som inte var med ifjol, kört finalen 32 gånger från debuten 1990 med egentränade <strong>Play Around</strong> (e. Smokin Yankee), som slutade tvåa. Giant Diablo, Lie Detector, Tamla Celeber, Dibaba och Diana Zet har Örjan styrt till vinst. I år kör han <strong>S.G.Empress</strong> (e. Readly Express).</p>



<p>Johnny Takter har inte kört finalen sedan han segrade med Cash Crowe för sju år sedan. Hans övriga vinnarhästar är Blues Office, Birminghim, Backfire och Ruby Trap.</p>



<p>Bakom Kihlström och Takter skuggar tillfälligt (?) pensionerade domarbasen Erik Adielsson med fyra vinster efter att ha segrat två år i rad med Stall Courant-ägda ston: 2023 med Sabine Kagebrant-tränade Jovility och bakom Adrian Kolgjini-tränade Karaboudjan ifjol. Eriks övriga vinnare är Sweet As Candy 2000 och Lotuschic 2006.</p>



<p>Av kuskarna i årets final har, förutom Kihlström, tre kuskar vunnit finalen: Björn Goop styrde Princess Face åt Lutfi Kolgjini 2016 och har egentränade <strong>Scarfo Pellini</strong> (e. Walner) i år. Carl Johan Jepson har en seger med Activity 2019 och kör nu Fredrik Wallins <strong>Matchmadeinheaven</strong> (e. S.J.’s Caviar). Per Lennartsson vann med Simb Capi 1998 och kör Ola Åsebös <strong>Pretty Be Linda</strong> (e. Varenne) i år.</p>



<p><strong>Segerrikaste kuskar i Drottningpokalen:</strong></p>



<ul class="wp-block-list">
<li>Fem segrar: Örjan Kihlström, Johnny Takter</li>



<li>Fyra segrar: Erik Adielsson</li>



<li>Tre segrar: Robert Bergh, Olle Goop</li>



<li>Två segrar: Stig H Johansson, Bo Näslund, Åke Svanstedt</li>
</ul>



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



<p class="has-drop-cap">Första B-tränaren att plocka fram en vinnare i loppets 42-åriga historia var Solvallaamatören Lennart Wikström som i <strong>Simb Capi</strong> (e. Probe) skapade en riktig toppmärr. På hästen som treåring vann hon både Svenskt Trav-Oaks och Breeders Crown och fyraåringssäsongen fick en flygande start med segrar i Ina Scots Ära och Drottningpokalen. När hon vann det sistnämnda loppet var det tionde raka (!) triumfen.</p>



<p>Inför Stochampionatet i juli såldes Simb Capi till tyske storhästägaren Michael Schröer och i Lutfi Kolgjinis regi plockades även Axevallas storlopp hem. Efter galopp i kval till Svenskt Travderby. spelad till tolv för tio – slutade Simb Capi tvåa i italienska storloppet Gran Premio Continentale i Kolgjinis regi innan Simb Capi lämnade Sverige för att fortsätta tävlingskarriären i Tyskland hos privattränaren Veijo Kivioja.<br>63 starter (29–7–6), 1.11,5ak*/4.950.361 kr, blev facit för Simb Capi som gjorde sin sista start som åttaåring 2002.</p>



<p>2023 fick Wikström sällskap när Sabine Kagebrant tränade <strong>Joviality</strong> (e. Chapter Seven). Kort efter triumfen på Åby blev Sabine proffstränare och bytte B till A.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/prettybelinda-617x333.jpg" alt="" class="wp-image-714008"/><figcaption class="wp-element-caption">Pretty Be Linda och Ola Åsebö. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>En B-tränare finns med även i årets finalfält, nämligen Ola Åsebö-tränade <strong>Pretty Be Linda</strong> (e. Varenne). Hon vann en av två starter som tvååring, men gick faktiskt segerlös ur treåringssäsongen som ändå inbringade 1.243.000 kronor, där andraplatsen i långa E3 för ston var främsta meriten.</p>



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



<p class="has-drop-cap">Pappa Peter vann aldrig Drottningpokalen som tränare och sonen Johan Untesteiner väntar också på första segern. Ifjol hade Johan tre chanser i finalen, där <strong>Willa Explosive</strong> (e. Explosive Matter) tog andraplatsen efter att ha släppt ledningen till vinnande Karaboudjan.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/johanuntersteiner3-617x333.jpg" alt="" class="wp-image-519438"/><figcaption class="wp-element-caption">Johan Untersteiner. Foto: Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Nu har stall Untersteiner laddad om med en duo i final. Johan kör <strong>Kinky Rain</strong> (e. Muscle Hill), vars mamma <strong>Alexia Ås</strong> (e. Conway Hall) slutade tvåa i Drottningpokalen 2005 bakom Fama Currit. Som treåring vann Alexia Ås Oaks i Roger Walmanns regi.<br>Untersteiners andra finalist körs av Peter och <strong>Elegance Silvio</strong> (e. Maharajah) vann Breeders Crown-försök och kvalade in till finalen i Eskilstuna som treåring.</p>



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



<p class="has-drop-cap">Med två startande avkommor sitter Propulsionen i överläge gentemot övriga avelshingstar i Drottningpokalen. Propulsion hade sin första och enda hittills startande finalist i High Hope Lee, som var i placerad för två år sedan. Nu heter Propulsions hopp <strong>Vivillion</strong> och <strong>Mellby Maleficent</strong>.</p>



<p>Av årets avelshingstar har Muscle Hill skapat två drottningar tidigare genom Princess Face och Fifty Cent Piece, medan Readly Express (Chebba Mil), Varenne (Lie Detector) och Walner (Karaboudjan) har varsin vinnare.</p>



<p><strong>Avelshingstar i Drottning Silvias Pokal:</strong><br><em>Avelshingst (finalist 2025) – Tidigare finalister – Resultat</em></p>



<ul class="wp-block-list">
<li><strong>Face Time Bourbon</strong> (1) – 1 – Naomi Bros (4) 2024</li>



<li><strong>Maharajah</strong> (1) – 12 – Felicity Shagwell (0) 2019, Intake (0) 2019, Zeta Wise As (0) 2019, Nikita Sunrise (0) 2021, Stella Nova Race (0) 2021, Deborah S.H. (2) 2022, Kayla Westwood (2) 2023, O’ Mara Zon (3) 2023, Mellby Korall (4) 2023, Riverdale Z. (0) 2023, Sommerbrise (0) 2023, Staro Raili (0) 2024</li>



<li><strong>Muscle Hill</strong> (1) – 12 – Princess Face (1) 2016, Natalie de Vie (5) 2016, Swiss Account (0) 2016, Feed Your Head (0) 2018, Zourane Kronos (0) 2019, Ganga Bee (6) 2020, Schweppes (0) 2020, Fifty Cent Piece (1) 2021, Bank Wise As (6) 2021, Namaste (0) 2021, Glamorous Rain (3) 2022, Countess Face (0) 2024</li>



<li><strong>Propulsion</strong> (2) – 1 – High Hope Lee (0) 2023</li>



<li><strong>Readly Express</strong> (1) – 6 – Honey Mearas (2) 2021, Helluva Am (5) 2021, Kirsi Boko (0) 2021, Chebba Mil (1) 2022, Bright Crystal (0) 2022, Farina (0) 2024</li>



<li><strong>S.J.’s Caviar</strong> (1) – 3 – Global Upper Style (2) 2018, Conrads Rödluva (2) 2019, Olga Tooma (0) 2022</li>



<li><strong>Varenne</strong> (1) – 5 – Lie Detector (1) 2008, Lily Kronos (0) 2009, Lotuscherie (0) 2014, Room to Go (0) 2014, Utrecht Rapid (3) 2017</li>



<li><strong>Walner</strong> (1) – 1 – Karaboudjan (1) 2020</li>



<li><strong>Brillantissime</strong> (1), <strong>Robert Bi</strong> (1) och <strong>Winter Harbor</strong> (1) har inga startande avkommor tidigare.</li>
</ul>



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



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2024/07/winterharborlisaphoto.jpg" alt="" class="wp-image-603825"/><figcaption class="wp-element-caption">Winter Harbor. Foto Lisa Photo</figcaption></figure>



<p class="has-drop-cap">Den okända kortet bland fäderna är USA-födde hingsten <strong>Winter Harbor</strong> (e. Muscle Hill), vars dotter J.H.Ellen är en av blott två svenskfödda avkommor till Winter Harbor. Denne var en riktig dyring som unghäst och ropades in för 240.000 dollar i Lexington som ettåring.</p>



<p>Han tränades av Tony Alanga och debuterade på bästa sätt när han vann debuten i Kindergarten Series på 1.12,2a/1.609 meter på Meadowlands i juli som tvååring.<br>Bågen spändes mot försök till Peter Haughton Memorial i livets andra start. Han nådde final i det stora tvååringsloppet efter femteplatsen på 1.11,6 i försöket, men galopperade bort sig i finalen. Som treåring slutade Winter Harbor fyra i finalen av Canadian Trotting Classic (C$687.000) och var även finalist i Breeders Crown ($500.000).</p>



<p>Han fortsatte att tävla i USA som fyraåring och noterade rekordet 1.09,9ak på Meadowlands. Totalt gjorde hingsten 20 starter (5-3-2) i Nordamerika, innan han bjöds ut på Tattersalls January Mixed Sales 2018 på Meadowlands som femåring. Där ropades han in av Oskar Florhed i kommision för 50.000 dollar och reste över Atlanten till sitt nya hemland Finland.</p>



<p>Hingsten testades i regi Ossi Nurmonen, men gick lottlös från fem starter som fem- och sexåring efter avslutade avelssäsonger. Sista starten gjordes i december 2019, innan han övergick till avel på heltid. Winter Harbors första kull föddes 2019 och är också den största med 32 avkommor. 2020 föddes 18, 2021 fick han åtta, innan det blev blott fyra respektive en avkomma de kommande åren.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/5j.h.ellen-617x333.jpg" alt="" class="wp-image-655184"/><figcaption class="wp-element-caption">J.H.Ellen spurtar till vinst för Björn Goop i BC-semifinal ifjol. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Förutom J.H.Ellen är hans enda svenskfödda avkomma treårige hingsten <strong>J.H.Birdcherryman</strong>, som också tränas av Björn Goop och ägs av Gnosjö Personaluthyrning AB.</p>



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



<p class="has-drop-cap">Tre uppfödare har tagit två vinster. Ellert Larsson, Sigtuna, var mannen bakom <strong>Drottning Sund</strong> (e. Tibus) och <strong>Itaka Sund</strong> (e. Sugarcane Hanover), medan två av sex vinnande USA-importer kom från Perretti Farms, nämligen <strong>Love n’Hate</strong> (e. Muscles Yankee) och <strong>Ruby Trap</strong> (e. Explosive Matter).</p>



<p>Am Bloodstock har fött upp de senaste två årens vinnare <strong>Joviality</strong> (e. Chapter Seven) och <strong>Karaboudjan</strong> (e. Walner), men har någon uppfödning i årets final, som kommer från tolv olika uppfödare.</p>



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



<p class="has-drop-cap">Utlandsfödda hästar fått vara med i pokalloppen 23 gånger och sedan premiären 2002, där svenskfödda <strong>Blues Office</strong> (e. Foreign Office) segrade, har åtta icke-svenska ston vunnit – sju födda i USA och 2022 års vinnare <strong>Chebba Mil</strong> (e. Readly Express), som föddes i Italien.</p>



<p>I år saknas utlandsfödda inslag i finalen, men två deltagare har mestadels tränats utanför Sveriges gränser.<br>Förutom Paul Hagoorts <strong>O’Hara Boko</strong> (e. Robert Bi) kommer norrmannen Geir Vegard Gundersen med <strong>Arctic Angel</strong> (e. Face Time Bourbon), som körs av sonen Magnus. Fast Arctic Angel är en van besökare i sitt födelseland. Av livets nio starter har åtta gjorts i Sverige med tre segrar i utdelning.</p>



<p><strong>Utlandsfödda vinnare:</strong><br><em>År, vinnare (far) – Tränare</em></p>



<ul class="wp-block-list">
<li>2007 Birminghim (e. Striking Sahbra) – Harald Lunde</li>



<li>2009 Mystic Lady U.S. (e. Andover Hall) – Åke Svanstedt</li>



<li>2012 Love N’Hate (e. Muscles Yankee) – Åke Svanstedt</li>



<li>2013 Gisela Ås (e. Infinitif) – Åke Svanstedt</li>



<li>2015 Ruby Trap (e. Explosive Matter) – Stefan Melander</li>



<li>2021 Fifty Cent Piece (e. Muscle Hill) – Robert Bergh</li>



<li>2022 Chebba Mil (e. Readly Express) – Paul Hagoort</li>



<li>2024 Karaboudjan (e. Walner) – Adrian Kolgjini</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/10vivillion2-617x333.jpg" alt="" class="wp-image-645598"/><figcaption class="wp-element-caption">Vivillion, Daniel Wäjersten och skötaren Ebba Karbelius efter segern i Svenskt-Trav Oaks. Nu jagar de segern i Drottningens pokal. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Dubbla chanser att få stå vid en vinnare av Drottning Silvas Pokal. De förutsättningarna har Jeanette Klasson, anställd av Johan Untersteiner. Hon sköter nämligen både Kinky Rain (e. Muscle Hill) och Elegance Silvio (e. Maharajah) i finalfältet.</p>



<p><strong>Här är hästskötarna bakom de tolv finalisterna i Drottning Silvias Pokal:</strong></p>



<ol class="wp-block-list">
<li>Scarfo Pellini – Julija Krejl</li>



<li>Vivillion – Ebba Karbelius</li>



<li>S.G.Empress – Malin Boman Friberg</li>



<li>Matchmadeinheaven – Matilda Bergström</li>



<li>Mellby Maleficent – Cecilia Lindén</li>



<li>Kinky Rain – Jeanette Klasson</li>



<li>Pretty Be Linda – Janika Häggman</li>



<li>Panthere d’Inverne – Constanza Flores</li>



<li>J.H.Ellen – Sara Agnas</li>



<li>O’Hara Boko – Kim Hagoort</li>



<li>Elegance Silvio – Jeanette Klasson</li>



<li>Arctic Angel – Lisa Alme</li>
</ol>


<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Drottning Silvias Pokal 1983-2024								</h3>
<div class="content">
<p><em>År/segrare – Far – Körsven – Tränare – Segertid</em></p>
<p>1983 <strong>Sussi Håleryd</strong> – Garry Håleryd – Ulf Nordin – Ulf Nordin – 1.16,4a<br />1984 <strong>Mariana W.</strong> – Scout Master – Olle Goop – Lars-Göran Carlsson (a) – 1.16,3a<br />1985 <strong>Kristina Palema</strong> – Quick Pay – Bo Näslund – Bo Näslund – 1.15,9a<br />1986 <strong>Intact</strong> – Netted – Olle Goop – Olle Goop – 1.17,4a<br />1987 <strong>Lass Dame</strong> – Quick Pay – Bo Näslund – Bo Näslund – 1.18,0a<br />1988 <strong>Gina Roy</strong> – Speedy Min – Stig H Johansson – Stig H Johansson – 1.17,0a<br />1989 <strong>Viva Mon</strong> – Super Mon – Åke Lindblom – Åke Lindblom – 1.16,5a<br />1990 <strong>Drottning Sund</strong> – Tibur – Björn Larsson – Björn Larsson – 1.15,3a<br />1991 <strong>Bowls Lady</strong> – Super Bowl – Stig H Johansson – Stig H Johansson – 1.17,2a<br />1992 <strong>Iata Käll</strong> – Ata Star L. – Jim Frick – Tommy Hanné – 1.16,6a<br />1993 <strong>Ina Scot</strong> – Allen Hanover – Kjell P Dahlström – Kjell P Dahlström – 1.14,9a<br />1994 <strong>Serena</strong> – Nuclear Kosmos – Christer Nylander – Christer Nylander – 1.15,2a<br />1995 <strong>Itaka Sund</strong> – Sugarcane Hanover – Fredrik B Larsson – Björn Larsson – 1.16,7a<br />1996 <strong>Sacrifice</strong> – Quick Pay – Olle Goop – Olle Goop – 1.16,6a<br />1997 <strong>Arnies Super Girl</strong> – Super Arnie – Dick S Jansson – Håkan Lindqvist (a) – 1.15,1a<br />1998 <strong>Simb Capi</strong> – Probe – Per Lennartsson – Lennart Wikström (a) – 1.16,0a<br />1999 <strong>Cindy Bob</strong> – Giant Chill – Mats Karlsson – Hans Karlsson – 1.16,3a<br />2000 <strong>Sweet As Candy</strong> – Smasher – Erik Adielsson – Lars-Eric Magnusson – 1.15,3a<br />2001 <strong>Hilda Zonett</strong> – Spotlite Lobell – Robert Bergh – Robert Bergh – 1.15,0a<br />2002 <strong>Blues Office</strong> – Foreign Office – Johnny Takter – Petri Puro – 1.15,2a<br />2003 <strong>Rae Boko</strong> – Pine Chip – Jorma Kontio – Markku Nieminen – 1.15,1a<br />2004 <strong>Giant Diablo</strong> – Supergill – Örjan Kihlström – Roger Walmann – 1.15,6ag<br />2005 <strong>Fama Currit</strong> – Viking Kronos – Peter Ingves – Petri Puro – 1.14,6a<br />2006 <strong>Lotuschic</strong> – Pine Chip – Erik Adielsson – Stig H Johansson – 1.14,5a<br />2007 <strong>Birminghim</strong> – Striking Sahbra – Johnny Takter – Harald Lunde – 1.13,6a<br />2008 <strong>Lie Detector</strong> – Varenne – Örjan Kihlström – Stefan Hultman – 1.13,6a<br />2009 <strong>Mystic Lady U.S.</strong> – Andover Hall – Robert Bergh – Åke Svanstedt – 1.13,7a<br />2010 <strong>Viola Silas</strong> – Lindy Lane – Fredrik Persson – Fredrik Persson – 1.12,9a<br />2011 <strong>Tamla Celeber</strong> – Cantab Hall – Örjan Kihlström – Roger Walmann – 1.13,0a<br />2012 <strong>Love n’Hate</strong> – Muscles Yankee – Åke Svanstedt – Åke Svanstedt – 1.14,2a<br />2013 <strong>Gisela Ås</strong> – Infinitif – Åke Svanstedt – Åke Svanstedt – 1.12,4a<br />2014 <strong>Backfire</strong> – Offshore Dream – Johnny Takter – Tomas Malmqvist – 1.12,6a<br />2015 <strong>Ruby Trap</strong> – Explosive Matter – Johnny Takter – Stefan Melander – 1.13,3a<br />2016 <strong>Princess Face</strong> – Muscle Hill – Björn Goop – Lutfi Kolgjini – 1.13,1a<br />2017 <strong>Cash Crowe</strong> – Ready Cash – Johnny Takter – Petri Puro – 1.12,7a<br />2018 <strong>Dibaba</strong> – Ready Cash – Örjan Kihlström – Roger Walmann – 1.11,4a<br />2019 <strong>Activated</strong> – Jocose – Carl Johan Jepson – Fredrik Wallin – 1.11,6a<br />2020 <strong>Diana Zet</strong> – Hard Livin – Örjan Kihlström – Daniel Redén – 1.12,6a<br />2021 <strong>Fifty Cent Piece</strong> – Muscle Hill – Robert Bergh – Robert Bergh – 1.12,6a<br />2022 <strong>Chebba Mil</strong> – Readly Express – Robin Bakker – Paul Hagoort – 1.11,7a<br />2023 <strong>Joviality</strong> – Chapter Seven – Erik Adielsson – Sabine Kagebrant – 1.12,4a<br />2024 <strong>Karaboudjan</strong> – Walner – Erik Adielsson – Adrian Kolgjini – 1.12,5a</p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
