
<p class="has-drop-cap wp-block-paragraph">Halva fältet från två tränare. Så ser det ut i årets upplaga av Drottning Silvias Pokal, där både Adrian Kolgjini och Johan Untersteiner har en trio i finalen.</p>



<p class="wp-block-paragraph">Ingen av dem har vunnit loppet tidigare, men Adrian kan luta sig emot pappa Lutfis tränartriumf med <strong>Princess Face</strong> (e. Muscle Hill) 2016 tillsammans med Björn Goop. Adrian har själv tränat två tidigare finalister, där A Perfect Face (e. Classic Photo) lyckats bäst med fjärdeplatsen 2022.</p>



<p class="wp-block-paragraph">Johan har haft tre finalister som tränare, där fjolårets fjärdeplats med <strong>Mellby Korall</strong> (e. Maharajah) är bästa resultatet.</p>



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



<p class="wp-block-paragraph"><em>Åby lördag 4 maj, förstapris 1.000.000 kr</em><br><strong>2.140 meter autostart:</strong><br><em>Hästnamn (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Willa Explosive</strong> (e. Explosive Matter) – Johan Untersteiner</li>



<li><strong>Countess Face</strong> (e. Muscle Hill) – Adrian Kolgjini</li>



<li><strong>Eteria</strong> (e. Tactical Landing) – Ulf Ohlsson (Reijo Liljendahl)</li>



<li><strong>Xia Lloyd</strong> (e. Raja Mirchi) – Dante Kolgjini (Adrian Kolgjini)</li>



<li><strong>Karaboudjan</strong> (e. Walner) – Erik Adielsson (Adrian Kolgjini)</li>



<li><strong>Ninetta Boko</strong> (e. Father Patrick) – Robbin Bot (Erwin Bot)</li>



<li><strong>Naomi Bros</strong> (e. Face Time Bourbon) – Mika Forss (Mikael Melefors)</li>



<li><strong>Kinglet Bird</strong> (e. Nuncio) – Örjan Kihlström (Daniel Redén)</li>



<li><strong>Farina</strong> (e. Readly Express) – Stefan Persson (Johan Untersteiner)</li>



<li><strong>Staro Raili</strong> (e. Maharajah) – André Eklundh (Sofia Aronsson)</li>



<li><strong>Lightning Stride</strong> (e. Twister Bi) – Carl Johan Jepson (Jerry Riordan)</li>



<li><strong>Monrose Wine</strong> (e. Nuncio) – Peter Untersteiner (Johan Untersteiner)</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/2023/10/countessface-617x333.jpg" alt="" class="wp-image-508585"/><figcaption class="wp-element-caption">Countess Face och Adrian Kolgjini. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Adrian Kolgjini var kungen av försöken till Drottning Silvias Pokal och vann tre av fem uttagningslopp. Den häst som Adrian hållit högst hittills är <strong>Countess Face</strong> (e. Muscle Hill), som vunnit hälften av livets tolv starter.<br>– Jag har alltid hållit henne som bäst i kullen, men hon har tävlat mot sig själv. Det ligger närmast till hands att köra henne i ledningen av mina tre. Det blir första starten med rycktussar och det kändes i träning att det gjorde skillnad. Det är en växel som jag vill ha på henne, och om det är rätt växel kommer det att klicka i ordentligt, sade Adrian Kolgjini till ATG Live.</p>



<p class="wp-block-paragraph"><strong>Karaboudjan</strong> (e. Walner) tävlade som unghäst i regi Marcus Melander och kom till Sverige i november.<br>– Jag har nog underskattat henne lite. Hon tränade på vinter och har sett ut som en halvtrevlig märr, men när hon har börjat tävla ser det ut som en klasshäst. Även i träning har hon blivit annorlunda och fått en helt annan spänst. Hon har verkligen utvecklats och är mycket bättre än vad hon var för någon månad sedan. Senast kände jag att hon är redo att gå barfota och det kommer att passa henne fint, hon blir lite friare, sade Kolgjini.</p>



<p class="wp-block-paragraph">Kometen i stallet är <strong>Xia Lloyd</strong> (e. Raja Mirchi), som vann två lopp och tjänade 193.000 kronor förra året. I år har det blivit fyra segrar på fem starter och 535.000 kronor in på kontot.<br>– Hon har fått starta på hela sitt tävlingsliv, aldrig haft något riktigt break, men har blivit starkare och bättre av det. Jag vet inte vad som hände på vårkanten, hon lyfte sig med 30-40 meter och det är en jätteöverraskning att hon är här idag. Hon har tagit overkliga steg de senaste månaderna, men slår ur underläge nu. Det blir första gången barfota fram och det kommer att ge en kick, sade Adrian.</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/2024/05/willaexplosive-617x333.jpg" alt="" class="wp-image-579506"/><figcaption class="wp-element-caption">Johan Untersteiners Willa Explosive. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Etta, tvåa, trea var resultaten för Johan Untersteiners finaltrio i uttagningsloppen och han sitter själv upp bakom vinnaren <strong>Willa Explosive</strong> (e. Explosive Matter). Johan fick välja spår först av alla i lottningen och satte dit Willa Explosives namn vid nummer ett.<br>– Jag var väldigt nöjd med henne senast, hon kändes fin. Det var tufft tempo men när luckan kom på open strech vann hon rätt enkelt och jag känner mig inte slagen på förhand nu. Hon har växt på sig i vinter och var bra redan ifjol där hon hade lite stolpe ut. Jag valde först och tog spår ett, hon har blivit mer startsnabb och vi måste vara i främre träffen om vi ska kunna vinna, sade Johan Untersteiner till V65 Direkt.</p>



<p class="wp-block-paragraph">Johans två övriga finalister inleder från bakspår.<br>– <strong>Farina</strong> (e. Readly Express) är väldigt liten, i klass med Delicious U.S. Hon har väldigt fin gång fast hon är så liten, ofta känns små häst som att köra ponnytravare, men hon har fint steg. Kommer hon till så kan hon ta ner många till slut. Hon går med skor som senast och det kändes bättre än barfota<br>– <strong>Monrose Wine</strong> (e. Nuncio) känns som en P21-häst i långsamma tempon, men när man ökar farten sträcker hon på benen. Hon gjorde ett strong lopp i försöken med tredjespår sista varvet, sade Johan.</p>



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



<p class="has-drop-cap wp-block-paragraph">En kvartett toppar statistiken över flest tränarsegrar. 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 class="wp-block-paragraph">Ingen av dessa har häst till start i årets final, där Daniel Redén är den ende i fältet som har en tränarseger sedan tidigare. 2020 blev <strong>Diana Zet</strong> (e. Hard Livin) drottning på Åby.<br>Nu ställer Redén hoppet till <strong>Kinglet Bird</strong> (e. Nuncio), som anslöt till Redéns stall efter femteplatsen i långa E3-finalen förra sommaren. Hos Redén slutade hon trea i korta E3 och kvalade in till Oaks efter försöksvinst.</p>



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



<p class="has-drop-cap wp-block-paragraph">Petri Puro var mannen bakom verket med trion Blues Office 2002, Fama Currit 2005 och Cash Crowe 2017 – men inte bara det. Han var även ägare till två av vinnarna: Blues Office och Cash Crowe. Därmed ståtar han tillsammans med Srf Stable (Dibaba 2018 och Fifty Cent Piece 2021) och Stall Courant AB (Princess Face 2016 och Joviality 2023) med två ägarsegrar i Drottningpokalen.</p>



<p class="wp-block-paragraph">Courant är ensam bland dessa att ha häst i årets final, där hoppet om att kli8va upp som ensam etta med tre segrar står till <strong>Karaboudjan</strong> (e. Walner), som även är uppfödd av Am Bloodstock.<br><strong>Tamla Celeber</strong> (e. Cantab Hall) då? Ja, när hon segrade 2011 i Courants röda dress med gul hästsko, så skedde det under ägarpseudonymen Am Bloodstock II AB, Halmstad.</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/2023/09/kingletbirdokm230913adamstromstalltz-617x440.jpg" alt="" class="wp-image-496068"/><figcaption class="wp-element-caption">Kinglet Bird och Örjan Kihlström. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Ö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. <strong>Giant Diablo, Lie Detector, Tamla Celeber, Dibaba</strong> och <strong>Diana Zet</strong> har Örjan styrt till vinst. I år kör han <strong>Kinglet Bird</strong> (e. Nuncio).<br>Johnny Takter har inte kört finalen sedan han segrade med <strong>Cash Crowe</strong> (e. Ready Cash) för sju år sedan. Hans vinnarhästar är <strong>Blues Office, Birminghim, Backfire, Ruby Trap</strong> och Cash Crowe.</p>



<p class="wp-block-paragraph">Av kuskarna i årets final har, förutom Kihlström, titelförsvararen Erik Adielsson vunnit tre gånger tidigare. Med <strong>Sweet As Candy</strong> 2000, <strong>Lotuschic</strong> 2006 och <strong>Joviality</strong> förra året och nu sitter han upp bakom ett annat Courant-sto: <strong>Karaboudjan</strong> (e. Walner). Även Carl Johan Jepson har en seger med <strong>Activity</strong> 2019. Nu ställs hoppet till <strong>Lightning Stride</strong> (e. Twister Bi).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/med-trippla-grupp-i-chanser/" target="_blank" rel="noreferrer noopener">––> Så här säger Carl Johan Jepson om sina storloppsuppsittningar på Åby.</a></p>



<p class="wp-block-paragraph"><strong>Segerrikaste kuskar i Drottningpokalen:</strong></p>



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



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



<li>Två segrar: Stig H Johansson, Bo Näslund, Åke Svanstedt</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/2024/05/naomibros-617x333.jpg" alt="" class="wp-image-579507"/><figcaption class="wp-element-caption">Mikael Melefors-tränade Naomi Bros och Mika Forss. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Första B-tränaren att plocka fram en vinnare i loppets 41-å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 class="wp-block-paragraph">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 class="wp-block-paragraph">Ifjol 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>



<p class="wp-block-paragraph">En B-tränare finns med även i årets finalfält, nämligen Mikael Melefors-tränade <strong>Naomi Bros</strong> (e. Face Time Bourbon), som testades en hel del i årgångssammanhang som treåring. Då slutade hon bland annat tvåa i divisionsloppet E3 och kvalade in till Svenskt Trav-Oaks.</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/2024/02/starorailiaem240203adamstromstalltz-617x398.jpg" alt="" class="wp-image-548445"/><figcaption class="wp-element-caption">Sofia Aronsson-tränade Staro Raili och André Eklundh. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Hon kostade 160.000 kronor som ettåring på Kriterieauktionen och gick under klubban igen som treåring, där hon gick för 620.000 kronor på Traveras auktion. Det handlar om Sofia Aronsson-tränade <strong>Staro Raili</strong> (e. Maharajah), som ropades in på Travera av storhästägaren och ordföranden i Färjestads Travsällskap Patrik Hjelte (Hjelte Restaurang AB, Karlstad).</p>



<p class="wp-block-paragraph">Staro Raili var ostartad när Hjelte slog till förra vintern och har inlett karriären sent men toppfint hos Aronsson. Fem segrar på nio starter och etta-tvåa i två avdelningar av Margaretas Tidiga Unghästserie finns på den växande meritlistan.</p>



<p class="wp-block-paragraph">Halva fältet har faktiskt varit uppe i auktionsringen och så här mycket kostade de övriga:</p>



<ul class="wp-block-list">
<li><strong>Eteria</strong> (e. Tactical Landing) 40.000 euro på ITS-auktionen i Italien 2021.</li>



<li><strong>Naomi Bros</strong> (e. Face Time Bourbon) 200.000 kronor för tävlingsrätten på Sweden International Yearling Sales 2021.</li>



<li><strong>Farina</strong> (e. Readly Express) 225.000 kronor på Menhammars septemberauktion 2021.</li>



<li><strong>Lightning Stride</strong> (e. Twister Bi) 6.000 euro på finska ettåringsauktionen 2021.</li>



<li><strong>Kinglet Bird</strong> (e. Nuncio) 160.000 kronor som tvååring på Courantauktionen 2022.</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">Två uppfödare har tagit två vinster. Ellert Larsson, Sigtuna, var mannen bakom <strong>Drottning Sund</strong> (e. Tibur) 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 class="wp-block-paragraph">Lutfi Kolgjini har tidigare fött upp vinnaren <strong>Princess Face</strong> (e. Muscle Hill) tillsammans med Anna Svensson och har <strong>Countess Face</strong> (e. Muscle Hill) i år tillsammans med Johann Schembri.</p>



<p class="wp-block-paragraph">Am Bloodstock födde upp fjolårsvinnaren <strong>Joviality</strong> (e. Chapter Seven) och ställer årets hopp till <strong>Karaboudjan</strong> (e. Walner).</p>



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



<p class="has-drop-cap wp-block-paragraph">Elitloppsvinnaren <strong>Nuncio</strong> (e. Andover Hall) är ensam bland avelshingstarna om att ha två avkommor i finalen. Detta med hingstens andra kull på travbanorna. Kinglet Bird och Monrose Wine är duon som 28-faldige miljonären hoppas på i Drottningpokalen.<br>Tre debuthingstar har finalister: Face Time Bourbon, Tactical Landing och Walner.</p>



<p class="wp-block-paragraph">Muscle Hill har bästa facit av avelshingstarna med två vinnare i Drottningpokalen. I år har han <strong>Countess Face</strong> i final. <strong>Farinas</strong> pappa Readly Express har lämnat en vinnare tidigare.</p>



<p class="wp-block-paragraph"><strong>Avelshingstar i Drottning Silvias Pokal:</strong><br><em>Hingst (finalister 2024) – Tidigare finalister (resultat)</em></p>



<ul class="wp-block-list">
<li><strong>Explosive Matter</strong> (1) – 1 – Ruby Trap (1) 2015</li>



<li><strong>Maharajah</strong> (1) – 11 – 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</li>



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



<li><strong>Raja Mirchi</strong> (1) – 6– Treasure Kronos (3) 2016, Pioneer Face (0) 2016, Vanquish Kronos (3) 2018, Elsa America (0) 2018, Jiggi (6) 2023, Stens Retention (0) 2023</li>



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



<p class="wp-block-paragraph"><strong>Inga tidigare finalister:</strong> Face Time Bourbon* (1), Father Patrick (1), Nuncio (2), Tactical Landing* (1), Twister Bi* (1) och Walner (1).<br><em>*  har sin första kull född 2020.</em></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/2023/06/eteriauo-617x333.jpg" alt="" class="wp-image-457226"/><figcaption class="wp-element-caption">Reijo Liljendahl-tränade Eteria. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p class="wp-block-paragraph">I år finns tre utlandsfödda ston med i finalen: italienska <strong>Eteria</strong> (e. Tactical Landing), amerikanska <strong>Karaboudjan</strong> (e. Walner) och finskfödda <strong>Lightning Stride</strong> (e. Twister Bi).</p>



<p class="wp-block-paragraph"><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>
</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/2023/10/9ninettaboko-617x333.jpg" alt="" class="wp-image-503472"/><figcaption class="wp-element-caption">Oakstvåan Ninetta Boko. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4 av Drottningfinalisterna var med i treåriga stona största lopp förra året, Svenskt Trav-Oaks. Där lyckades Erwin Bot-tränade och Boko-uppfödda <strong>Ninetta Boko</strong> (e. Father Patrick) bäst och följde upp segern i kvalet med andraplatsen bakom Adriatica (e. Bold Eagle) i finalen.</p>



<p class="wp-block-paragraph"><strong>Farina</strong> (e. Readly Express) knep sista slanten, <strong>Naomi Bros</strong> (e. Face Time Bourbon) slutade oplacerad medan <strong>Willa Explosive</strong> (e. Explosive Matter) tvingades strykas.</p>



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



<p class="has-drop-cap wp-block-paragraph">Hälften av stona var ute redan som tvååringar och hälften av dem vann lopp. Flest starter gjorde <strong>Naomi Bros</strong> och <strong>Ninetta Boko</strong> med sex framträdanden vardera, medan <strong>Eteria</strong> vann sin enda start som tvååring.</p>



<p class="wp-block-paragraph"><strong>Här är resultaten som tvååringar:</strong></p>



<ul class="wp-block-list">
<li>Eteria (e. Tactical Landing) – 1 st: 1-0-0, 1.15,9k*/40.000 kr</li>



<li>Xia Lloyd (e. Raja Mirchi) – 2 st: 0-0-1, 1.16,2k/12.000 kr</li>



<li>Karaboudjan (e. Walner) – 2 st: 0-1-0, 1.12,6ak/30.780 kr</li>



<li>Ninetta Boko (e. Father Patrick) – 6 st: 0-2-3, 1.13,3ak/129.105 kr</li>



<li>Naomi Bros (e. Face Time Bourbon) – 6 st: 1-2-1, 1.15,2ak/145.000 kr</li>



<li>Lightning Stride (e. Twister Bi) – 5 st: 1-0-0, 1.15,5k*/134.800 kr</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/2023/10/6wilmakarlsson-617x333.jpg" alt="" class="wp-image-509502"/><figcaption class="wp-element-caption">Wilma Karlsson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Wilma Karlsson och Johanna Svensson får extra mycket att göra på lördagseftermiddagen. Duon är nämligen hästskötare till två finalister vardera i Drottningpokalen.<br>Wilma, som utsågs till Årets Komet förra året efter bland annat seger i Dam-SM, har Willa Explosive och Farina, medan Johanna selar ut Xia Lloyd och Countess Face.</p>



<p class="wp-block-paragraph"><strong>Skötare till Drottninghästarna:</strong><br><em>Hästskötare – Finalist</em></p>



<ul class="wp-block-list">
<li>Wilma Karlsson – Willa Explosive</li>



<li>Johanna Svensson – Countess Face</li>



<li>Pernilla Sundling – Eteria</li>



<li>Johanna Svensson – Xia Lloyd</li>



<li>Ingrid Elise Rod – Karaboudjan</li>



<li>Patricia van der Meer – Ninetta Boko</li>



<li>Anna Melefors – Naomi Bros</li>



<li>Jenny Sundin – Kinglet Bird</li>



<li>Wilma Karlsson – Farina</li>



<li>Madeleine Olsson – Staro Raili</li>



<li>Heli Tarrimaa – Lightning Stride</li>



<li>Clement Fouquet – Monrose Wine</li>
</ul>


<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-2025								</h3>
<div class="content">
<p class="wp-block-paragraph"><em>År/segrare – Far – Körsven – Tränare – Segertid</em></p>
<p class="wp-block-paragraph">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<br />2025 Panthere d&#8217;Inverne – Walner – André Eklundh – André Eklundh – 1.12,0a</p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
