
<p class="has-drop-cap wp-block-paragraph">När det handlar om tävlingsmeriter bland finalisterna i Drottning Silvias Pokal så handlar mycket om en enda häst: Sabine Kagebrant-tränade <strong>Joviality</strong> (e. Chapter Seven).<br>Det svenskfödda stoet tävlade som två- och treåring hos Marcus Melander och när det beslutades att hon skulle komma ”hem” till Sverige gjorde hon det efter 28 starter (20-4-2) på andra sidan Atlanten och över 17 miljoner kronor insprunget!</p>



<figure class="wp-block-image size-full is-resized"><img src="https://sulkysport.se/wp-content/uploads/2022/10/jovialitybspr221001adamstromstalltz.jpg" alt="" class="wp-image-361921" width="738" height="494"/><figcaption class="wp-element-caption">Hela gänget runt Joviality, som utsågs till ”Årets Treåriga Sto” i USA ifjol. Foto: Ada Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Som tvååring tjänade 895.341 dollar efter nio vinster och två andraplatser på tolv starter. Hon avslutade tvååringssäsongen med att vinna Breeders Crown ($600.000) och Goldsmith Maid ($479.450).<br>Som treåring vann Joviality elva lopp och slutade tvåa och trea vid två tillfällen på 16 starter. Joviality vann Triple Crown-loppet Yonkers Trot och slutade tvåa i Hambletonian Stakes bakom valacken Cool Papa Bell. Totalt inbringade hennes säsong 1.083.642 dollar, vinnarrekordet 1.08,6 och som slagen travade hon 1.08,4 som tvåa bakom Jiggy Jog i Kentucky Futurity Filly.</p>



<p class="wp-block-paragraph">Debuten på svensk mark slutade med en joggingtur och lätt seger från ledningen i försöket till Drottningpokalen tillsammans med Erik Adielsson.<br>Och i prispengar? 17.474.954 kronor för Joviality – och 7.783.013 kronor för övriga elva ston!</p>



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



<p class="has-drop-cap wp-block-paragraph">Tre tränare står bakom halva finalfältet. Conrad Lugauer kvalade in <strong>Riverdale Z.</strong> (e. Maharajah) och <strong>Jade Sisu</strong> (e. Ready Cash). Solvallatränaren Mattias Djuse har dubbla finalister i <strong>Kayla Westwood</strong> (e. Maharajah) och <strong>Beauvoir</strong> (e. Executive Caviar), medan Halmstads Johan Untersteiner mönstrar duon <strong>Mellby Korall</strong> (e. Maharajah) och <strong>Stens Retention</strong> (e. Raja Mirchi).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/kaylawestwoodmadm230421adamstromstalltz-617x389.jpg" alt="" class="wp-image-434139"/><figcaption class="wp-element-caption">Kayla Westwood och Magnus A Djuse vid segern i uttagningsloppet. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Av dessa har Kayla Westwood och Stens Retention de främsta meriterna. Djuses Kayla Westwood, som köptes av Nymanwänseth Byggmästare AB i Östersund för 1.050.000 kronor på Traveras internetauktion veckan före Oakskvalet, tjänade 1,6 miljoner som treåring efter bland annat delat tredjeplats i Oaks, fjärdeplatsen i långa E3 och seger i en avdelning av Margaretas Tidiga Unghästserie.</p>



<p class="wp-block-paragraph">Stens Retention (e. Raja Mirchi) satte punkt för treåringssäsongen genom att sluta tvåa i Breeders Crown-finalen.</p>



<p class="wp-block-paragraph">Från stonas största lopp ifjol, Svenskt Trav-Oaks, finns tre hästar i Drottningpolen. Förutom nämnda Oakstrean Kayla Westwood handlar det om Daniel Wäjerstens <strong>O’Mara Zon</strong> (e. Maharajah) och Claes Sjöströms <strong>Lawina</strong> (e. Uncle Lasse), som båda gick lottlösa från Oaks. O’Mara Zon kan istället se tillbaka på andraplatsen i korta E3 och fjärdeplatsen i Breeders Crown, dit även Lawina kvalade in.</p>



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



<p class="wp-block-paragraph"><em>Fyraåriga ston, 2.140 meter autostart</em><br><strong>Pris: </strong>1.000.000-500.000-250.000-120.000-80.000-50.000 kr</p>



<ol class="wp-block-list">
<li>Riverdale Z. (e. Maharajah) – Conrad Lugauer</li>



<li>O’Mara Zon (e. Maharajah) – Daniel Wäjersten</li>



<li>Kayla Westwood (e. Maharajah) – Magnus A Djuse (Mattias Djuse)</li>



<li>Joviality (e. Chapter Seven) – Erik Adielsson (Sabine Kagebrant)</li>



<li>Mellby Korall (e. Maharajah) – Johan Unterstener</li>



<li>Stens Retention (e. Raja Mirchi) – Peter Untersteiner (Johan Untersteiner)</li>



<li>Lawina (e. Uncle Lasse) – Carl Johan Jepson (Claes Sjöström)</li>



<li>Sommerbrise (e. Maharajah) – Per Nordström</li>



<li>Jiggi (e. Raja Mirchi) – Björn Goop (Fredrik Wallin)</li>



<li>Beauvoir (e. Executive Caviar) – Mats E Djuse (Mattias Djuse)</li>



<li>Jade Sisu (e. Ready Cash) – Jorma Kontio (Conrad Lugauer)</li>



<li>High Hope Lee (e. Propulsion) – Adrian Kolgjini (Lars I Nilsson)</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/2022/05/jiggi.madm220518adamstromstalltz-617x393.jpg" alt="" class="wp-image-304303"/><figcaption class="wp-element-caption">Jiggi. Foto: Adam Ström/stalltz.se</figcaption></figure>



<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 Gävletränaren Fredrik Wallin faktiskt är ensam om att veta hur det känns att vinna loppet. Hans toppsto <strong>Activated</strong> (e. Jocose) vann tillsammans med Carl Johan Jepson för fyra år sedan.<br>I år sätter Wallin hoppet till <strong>Jiggi</strong> (e. Raja Mirchi), vars största seger kom i ett Breeders Crown-försök på Mantorptravet förra sommaren.</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/04/riverdalezclm230421adamstromstalltz-617x375.jpg" alt="" class="wp-image-434141"/><figcaption class="wp-element-caption">Riverdale Z. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Uppfödare, tränare och körsven. Det är Conrad Lugauers roller bakom Maharajah-dottern <strong>Riverdale Z.</strong> Jägersrotränarens talang debuterade faktiskt inte förrän den 4 januari i år på hemmabanan Jägersro, klart senast av alla finalister, och med sex starter och sex segrar (!) innanför västen är Riverdale Z. minst rutinerad av finalisterna.</p>



<p class="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">Ytterligare en proffstränare har tagit sin egna uppfödning hela vägen till final. Lars I Nilsson tog fram <strong>High Hope Lee</strong> (e. Propulsion), vars mamma <strong>High Hope Face</strong> (e. Pine Chip), 1.10,9ak/1.561.907 kr, försökte kvala in till Drottningpokalen, men blev utslagen som sexa i försöket. Mormor <strong>Hannah Newmen</strong> (e. Nick Lobell) segrade å sin sida i Oaks 1996 i regi Ola Samuelsson.</p>



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



<p class="has-drop-cap wp-block-paragraph">De har vunnit Drottning Silvias Pokal flest gånger i historien som kuskar, men i lördagens upplaga finns varken Örjan Kihlström eller Johnny Takter med. För Kihlströms del är det första gången sedan 1995 som han inte finns med i programmet i finalen (hans uppsittning In Toto Sund ströks 2016). Totalt har Örjan kört finalen 32 gånger från debuten 1990 med egentränade <strong>Play Around</strong> (e. Smokin Yankee), som slutade tvåa.<br>Giant Diablo, Lie Detector, Tamla Celeber, Dibaba och Diana Zet har Örjan styrt till vinst.</p>



<p class="wp-block-paragraph">Johnny Takter har inte kört finalen sedan han segrade med <strong>Cash Crowe</strong> (e. Ready Cash) för sex år sedan. Hans vinnarhästar är Blues Office, Birminghim, Backfire, Ruby Trap och Cash Crowe.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/jovialityeam230421adamstromstalltz-617x379.jpg" alt="" class="wp-image-434137"/><figcaption class="wp-element-caption">Joviality vinner Drottningförsöket för Erik Adielsson. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Av kuskarna i årets final har Erik Adielsson vunnit två gånger tidigare. Med <strong>Sweet As Candy</strong> 2000 och <strong>Lotuschic</strong> 2006.<br>En seger vardera har Jorma Kontio (<strong>Rae Boko</strong> 2003), Björn Goop (<strong>Princess Face</strong> 2016) och Carl Johan Jepson (<strong>Activated</strong> 2019).</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: Robert Bergh, Olle Goop</li>



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



<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 <strong>Blues Office</strong> 2002, <strong>Fama Currit</strong> 2005 och <strong>Cash Crowe</strong> 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 (<strong>Dibaba</strong> 2018 och <strong>Fifty Cent Piece</strong> 2021) med två ägarsegrar i Drottningpokalen.</p>



<p class="wp-block-paragraph">Stall Courant AB, Heby, äger två av finalisterna: superstjärnan <strong>Joviality</strong> (e. Chapter Seven) och <strong>Jiggi</strong> (e. Raja Mirchi). En seger har stallet sedan tidigare när Lutfi Kolgjini-tränade <strong>Princess Face</strong> (e. Muscle Hill) vann 2016 tillsammans med Björn Goop och Goop kör Jiggi i årets final.</p>



<p class="wp-block-paragraph"><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/2021/11/sommerbrisemalgang-617x411.jpeg" alt="" class="wp-image-235373"/><figcaption class="wp-element-caption">Sommerbrise vid sin seger i försöket till Svensk Uppfödningslöpning. Foto: Mikael Rosenquist.</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">När bland annat fyra av tolv finalister – <strong>Joviality, Mellby Korall, Stens Retention</strong> och <strong>Jiggi</strong> – fortfarande ägs av sina uppfödare, så är andelen hästar som sålts på auktion väldigt liten.</p>



<p class="wp-block-paragraph">Ja , förutom ovan nämnda <strong>Kayla Westwood</strong> som gick upp i internetringen som treåring, så är det bara en finalist som sålts på landets unghästauktioner.<br>Det handlar om <strong>Sommerbrise</strong> (e. Maharajah), som Per Nordström ropade in som ettåring på Sweden International Yearling Sale 2020 för 130.000 kronor för hästägares räkning.</p>



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



<p class="has-drop-cap wp-block-paragraph">En enda B-tränare har plockat fram en vinnare i loppets 40-åriga historia, nämligen 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">En B-tränare finns med i årets finalfält, nämligen Sabine Kagebrant som fått tränaransvaret för <strong>Joviality</strong> (e. Chapter Seven), som anlände från Marcus Melanders stall i USA i mars. </p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">––> Här är Sulkysports stora reportage från besöket hos Joviality på Molnebo Gård utanför Heby</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank"> </a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">i</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">n</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">f</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">ö</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">r</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank"> </a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">u</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">t</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">t</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">a</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">g</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">n</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">i</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">n</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">g</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">s</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">l</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">o</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">p</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">p</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">e</a><a href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank" rel="noreferrer noopener">t</a><a rel="noreferrer noopener" href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank">. </a></p>



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



<p class="has-drop-cap wp-block-paragraph">Förra året slutade Fredrik Persson-tränade <strong>Deborah S.H.</strong> tvåa i Drottning Silvias Pokal och gav pappa Maharajah största framgången i loppet i hingstens sjätte försök som far. När årets upplaga ska avgöras ställer Menhammarhingsten upp med en stark laguppställning. Han är far till hela fem av de tolv finalisterna!</p>



<p class="wp-block-paragraph">Dessutom visade hans döttrar bästa form i uttagningsloppen, där tre av dem dessutom segrade: <strong>Riverdale Z., O’Mara Zon</strong> och <strong>Kayla Westwood</strong>. Maharajahs övriga hästar i Drottningpokalen är försökstvåan <strong>Mellby Korall</strong> och trean <strong>Sommerbrise</strong>. Snacka om maktdemionstration!</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/omarazon-617x333.jpg" alt="" class="wp-image-358330"/><figcaption class="wp-element-caption">O&#8217;Mara Zon och Daniel Wäjersten. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Med fem inkvalade avkommor är också Maharajah historisk i Drottningpokalen. Det tidigare rekordet delade Pershing – två gånger om dessutom – när fyra döttrar var i final både 1986 och 1987, samt Smasher som hade fyra startande döttrar 2000. En av dessa var vinnaren <strong>Sweet As Candy</strong>.</p>



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



<p class="wp-block-paragraph"><em>Hingst (antal 2023) – Tidigare finalister – Resultat</em></p>



<ul class="wp-block-list">
<li>Maharajah (5) – 6 – 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</li>



<li>Raja Mirchi (2) – 4 – Treasure Kronos (3) 2016, Pioneer Face (0) 2016, Vanquish Kronos (3) 2018, Elsa America (0) 2018</li>



<li>Ready Cash (1) – 6 – Cash Crowe (1) 2017, Caddie Lisieux (0) 2017, Dixi Sisu (0) 2017, Dibaba (1) 2018, Grande Diva Sisu (2) 2020, Donna Summer (0) 2022</li>



<li>Chapter Seven (1) – inga startande</li>



<li>Executive Caviar* (1) – inga startande</li>



<li>Propulsion* (1) – inga startande</li>



<li>Uncle Lasse (1) – inga startande</li>
</ul>



<p class="wp-block-paragraph"><em>* första årgången.</em></p>



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



<p class="has-drop-cap wp-block-paragraph">Utlandsfödda hästar fått vara med i pokalloppen 21 gånger 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 fjolårsvinnaren <strong>Chebba Mil</strong> (e. Readly Express), som föddes i Italien.</p>



<p class="wp-block-paragraph">I år tar tolv blågula ston plats bakom startbilen.</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>



<p class="has-drop-cap wp-block-paragraph">Fyra av stona tävlade som tvååringar, där <strong>Jovialitys</strong> resultat förstås sticker ut. <strong>Kayla Westwood</strong> vann två av tre starter, däribland Menhammar Stuteris Tvååringspris, innan hon avslutade första säsongen med tredjeplatsen i Vinterfavoriten. <strong>Jade Sisu</strong> (e. Ready Cash) gjorde två starter i Per Norddtröms regi som tvååring och debuterade bland annat som trea på 1.14,1a/1.680 meter i Hamburg.</p>



<p class="wp-block-paragraph">De främsta meriterna på svensk mark hade en annan Nordström-häst. <strong>Sommerbrise</strong> (e. Maharajah) gjorde sex starter, vann tre av dessa och sprang in 645.000 kronor som tvååring. Segrarna kom i Breeders Crown, Sweden International Yearling Sales Auktionslopp och uttagningslopp till Svensk Uppfödningslöpning, där hon slutade sexa i finalen som vanns av Tetrick Wania.</p>



<p class="wp-block-paragraph">Seger i ett Breeders Crown-försök blev största framgången som treåring och nu är hon framme vid sin andra stora final.</p>



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



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/04/mellbykorall1.jpg" alt="" class="wp-image-433623"/><figcaption class="wp-element-caption">Mellby Korall och Johan Untersteiner. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><strong>Bakom varje topphäst står en hästskötare. Här är gänget som kanske känner sin Drottningpokalfinalist allra bäst!</strong><br><strong>Två av dem, Eva Boel och Camilla Björk, har även hand om varsin finalist i Kungapokalen, Dancer Brodde respektive H.C.&#8217;s Crazy Horse.</strong></p>



<ul class="wp-block-list">
<li>Riverdale Z. – Karin Elias</li>



<li>O’Mara Zon – Camilla Björk</li>



<li>Kayla Westwood –  Nathalie Vingmyr</li>



<li>Joviality – Michaela Engström</li>



<li>Mellby Korall – Eva Boel</li>



<li>Stens Retention – Erik Cederlund</li>



<li>Lawina – Alvari Svarts</li>



<li>Sommerbrise – Sofie Dam</li>



<li>Jiggi –  Ellen Bergman</li>



<li>Beauvoir –  Tova Bergström</li>



<li>Jade Sisu – Eileen Bubbers</li>



<li>High Hope Lee –  Ida Lindberg</li>
</ul>



<figure class="wp-block-embed is-type-wp-embed is-provider-sulkysport wp-block-embed-sulkysport"><div class="wp-block-embed__wrapper">
<blockquote class="wp-embedded-content" data-secret="pqiccOAFJK"><a href="https://sulkysport.se/det-snackas-om-kungapokalen-3/">Det snackas om Kungapokalen&#8230;</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Det snackas om Kungapokalen&#8230;” &ndash; Sulkysport" src="https://sulkysport.se/det-snackas-om-kungapokalen-3/embed/#?secret=d67ykUGL43#?secret=pqiccOAFJK" data-secret="pqiccOAFJK" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>


<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>
