
<p class="has-drop-cap">1 Sista chansen att på egen hand kvala in till Breedeers Crown-semifinalerna på Solvalla den 3 november sker ikväll – på dubbla banor. <strong>Romme </strong>(första start 18.15) och <strong>Kalmar</strong> (start 18.27) är nämligen skådeplatser för både Breeders Crown-försöken och kvällens V86-omgång.</p>



<p>De åtta BC-försöken har lockat en hel del starka namn och det starkaste sällskapet dyker upp bland de fyraåriga stona på Romme. Här möts fjolårets Oaksvinnare <strong>Adriatica </strong>(e. Bold Eagle), Stochampionatsvinnaren <strong>Kinglet Bird</strong> (e. Nuncio), fyrfaldiga miljonärskan <strong>Secret Volo</strong> (e. Walner) och ytterligare tre miljonärskor i form av E3-vinnaren <strong>A Teaser </strong>(e. Flocki d’Aurcy), Derbystotvåan <strong>Dial Square </strong>(e. Ready Cash) och Drottningpokaltrean <strong>Eteria</strong> (e. Tactical Landing).</p>



<p>Motsvarande lopp i Kalmar går inte heller av för hackor med årets Stosprintervinnare <strong>Kitty Hawk </strong>(e. Fourth Dimension), Stochampionatstvåan <strong>Farina</strong> (e. Readly Express) och <strong>Knickers Sisu</strong> (e. Southwind Frank), tvåa i långa E3 ifjol och trea i Derbystoet.</p>



<p>Kvällens V86-omgång består till 100 procent av Breeders Crown-uttagningarna och Sulkysports spelstuga med spikar, drag och favoriter i fara publiceras som vanligt klockan 12.00 idag.</p>



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



<p class="has-drop-cap">2 28 platser per klass har det tävlats om hittills i år i Breeders Crown och bland ettorna i försöken finns Daniel Wäjerstens nybakade klassiska vinnare <strong>Bullet the Bluesky</strong> (e. Readly Express) och <strong>Vivillion </strong>(e. Propulsion), som vunnit varsitt försök bland treåringarna.</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. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>De fyra främsta i varje försök är säkrade plats i semifinalerna, medan övriga platser tillsätts genom anmälan och går till hästarna med högst startprissumma.</p>



<h2 class="wp-block-heading">Här är vinnarna hittills i Breeders Crown:</h2>



<ul class="wp-block-list">
<li><strong>Treåriga hingstar/valacker:</strong> <strong>Ronno</strong> (e. Walner) två segrar, <strong>Fly Equos Jet </strong>(e. Readly Express) två segrar, <strong>Vikens Love Kill</strong> (e. Tobin Kronos), <strong>Phantom Express </strong>(e. Readly Express), <strong>Bullet the Bluesky</strong> (e. Readly Express)</li>
</ul>



<ul class="wp-block-list">
<li><strong>Treåriga ston: Ballerina Girl</strong> (e. Father Patrick), <strong>Lavender</strong> (e. Walner), <strong>Unica S.L.M.</strong> (e. Googoo Gaagaa), <strong>S.G.Empress</strong> (e. Readly Express), <strong>Beedrill</strong> (e. Muscle Hill), <strong>Vivillion</strong> (e. Propulsion), <strong>Ready To Run H.C.</strong> (e. Nuncio)</li>
</ul>



<ul class="wp-block-list">
<li><strong>Fyraåriga hingstar/valacker: Express Cash</strong> (e. Readly Express), <strong>Bicc’s Tobee</strong> (e. Tobin Kronos), <strong>Macahan</strong> (e. Maharajah), <strong>Stens Rubin</strong> (e. Readly Express), <strong>Kuiper </strong>(e. Face Time Bourbon), <strong>Conrads Palle</strong> (e. Brillantissime), <strong>Devilish Hill</strong> (e. Muscle Hill)</li>
</ul>



<ul class="wp-block-list">
<li><strong>Fyraåriga ston: Madewithlove</strong> (e. Daley Lovin), <strong>Foxtail Pine</strong> (e. Maharajah), <strong>Secret Volo </strong>(e. Walner), <strong>Staro Raili</strong> (e. Maharajah),<strong> Eteria </strong>(e. Tactical Landing), <strong>A Teaser</strong> (e. Flocki d’Aurcy), <strong>Ninetta Boko</strong> (e. Father Patrick)</li>
</ul>



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



<p class="has-drop-cap">3 &#8221;Plåt-Sven&#8221;, eller Sven E S Andersson som var hans riktiga namn, var under många år en stor tränarprofil med bas på gården nära Ludvika i södra Dalarna och gjorde sig ett namn med <strong>Abbey Rozz</strong> (e. Armbro Nick), som köptes som en trashank i mitten av 1980-talet med några tusenlappar på priskontot. När karriären var över hade hästen sprungit in över 2,5 miljoner kronor.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/07/hustlerainmadm230706adamstromstalltz-scaled.jpg" alt="" class="wp-image-467686"/><figcaption class="wp-element-caption">Hustle Rain och Magnus A Djuse vid seger i Sprintermästaren. Ikväll startar han i Rommechansen. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p>Annars var det med flera unghästar under 2000-talet som Sven kom att skörda stora framgångar. Den främste var <strong>Seth Bowl</strong> (e. Born Quick), som när karriären summerats hade sprungit in över sex miljoner kronor och vunnit både E3 och Europeiskt Treåringschampionat.</p>



<p>I Italien köptes bröderna <strong>Calypso Capar</strong> (e. Supergill), som vann uppfödningslopp Gran Premio Allevatori i Rom som tvååring 2001, och <strong>Lord Capar</strong> (e. Varenne). 16 segrar på 21 starter som två- och treåring, däribland Gran Criterium i Milano 2007 och Ulf Thoresens Minneslopp året efter.</p>



<p>&#8221;Plåt-Sven&#8221; avled julen 2008 i en ålder av 77 år och sedan 2009 hedras han med ett minneslopp för treåringar på Romme. Ikväll namnger han Breeders Crown-försöket för treåriga hingstar och valacker på Romme.</p>



<p>Romme bjuder också på femåringsloppet Rommechansen som bjudit på vinnare som <strong>San Moteur</strong>, <strong>Don Fanucci Zet</strong>, <strong>Gigant Neo</strong>, <strong>Lookout Victory</strong>, <strong>Tamin Sandy</strong> och första upplagan Derbyvinnaren <strong>Spinoon</strong> för att nämna en handfull i den namnstarka listan.</p>



<p>Och på tal om ”Plåt-Sven” – 2001 segrade hans träning <strong>Seth Bowl</strong> tillsammans med Torbjörn Jansson! Årets upplaga ser hästar som Kriterievinnaren <strong>Xanthis Harvey</strong> (e. Propulsion), Sprintermästaren <strong>Hustle Rain</strong> (e. Raja Mirchi) och världsrekordtravaren <strong>S.I.P.</strong> (e. Bar Hopping).</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/10/16v86.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2024/10/16v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till kvällens tävlingar. </a></p>



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



<p class="has-drop-cap">4 I förra veckan avled en av norsk travsports största genom tiderna. Gunnar Eggen somnade in i en ålder av 78 år. På onsdag nästa vecka hålls Gunnars begravning i Grefsen kyrka i Oslo, skriver norska Trav- og Galopp-Nytt.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/eggengunnar-617x333.jpg" alt="" class="wp-image-648131"/><figcaption class="wp-element-caption">Gunnar Eggen. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p>– Då är det tävlingsfritt i Norge och det vore trevligt om kollegor och andra som känner pappa vill hedra honom en sista gång, säger Gunnars son Hans Jörgen Eggen till TGN.</p>



<p>Hans Jörgen berättar om Gunnars sista tid på Ullevål sjukhus.</p>



<p>– Han var kristallklar i huvudet in i det sista. Så sent om i onsdags (dagen före Gunnars bortgång, reds. anm.) pratade vi om hästar och han hängde med bra, men kroppen var inte samarbetsvillig längre.</p>



<p>Gunnar Eggen var den stora dominanten i norsk travsport under 1980- och 1990-talet. Hela 18 raka championat räknade han in på hemmabanan Bjerke och 1996 blev han europamästare. På meritlistan finns också tio segrar i det norska Derbyt och fyra vinster i Kriteriet.</p>



<p>Totalt vann han 5.546 lopp. Superåret 1998 segrade han tillsammans med <strong>Sugarcane Hanover</strong> i Olympiatravet, Oslo Grand Prix och framför allt March of Dimes på på Garden State Park i USA, där Eggens taktiska sinne gav seger mot storheter som Mack Lobell och Ourasi.</p>



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



<p class="has-drop-cap">5 Intresset för att delta i Breeders Crown för äldre travare var inte speciellt stort på andra sidan Atlanten och det krävs varken försök i den öppna avdelningen eller för stona sedan det anmälts elva respektive nio hästar. Nedanstående hästar går direkt till finalen den 26 oktober på Meadowlands.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/winnersbetddm241004adamstromstalltz-617x400.jpg" alt="" class="wp-image-642866"/><figcaption class="wp-element-caption">Lennart Ågrens uppfödning Winner&#8217;s Bet är en av tre hästar från Nancy Takters stall i Breeders Crown. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>I den öppna avdelningen tränas sex av elva hästar av svenskar och Nancy Takter plockar ut tre hästar, Marcus Melander selar ut en duo och Åke Svanstedt en travare. Två hästar har Åke Svanstedt i stonas uppgörelse och ägarna till både <strong>Nelson Brite Eagle</strong> och <strong>Call Me Goo </strong>har köpt in sig i loppet med 48.000 dollar vardera.</p>



<p><strong>Breeders Crown</strong> (öppen klass)</p>



<p><em>Namn (far) – Tränare</em></p>



<ul class="wp-block-list">
<li><strong>Ari Ferrari J</strong> (e. Walner) – Tony Alagna</li>



<li><strong>Asteroid </strong>(e. Creatine) – Jeff Cullipher</li>



<li><strong>Bestfriend Volo </strong>(e. Walner) – Nancy Takter</li>



<li><strong>Hasty Bid </strong>(e. My MVP) – Nancy Takter</li>



<li><strong>Hillexotic</strong> (e. Muscle Hill) – Todd Luther</li>



<li><strong>It’s Academic</strong> (e. Uncle Peter) – Ron Burke</li>



<li><strong>Logan Park</strong> (e. Archangel) – Robert Kyle Fellows</li>



<li><strong>Oh Well </strong>(e. Muscle Hill) – Marcus Melander</li>



<li><strong>Periculum </strong>(e. Muscle Hill) – Marcus Melander</li>



<li><strong>Up Your Deo </strong>(e. Walner) – Åke Svanstedt</li>



<li><strong>Winner’s Bet </strong>(e. Walner) – Nancy Takter</li>
</ul>



<p><strong>Breeders Crown</strong> (ston)</p>



<ul class="wp-block-list">
<li><strong>Baroness Hill</strong> (e. Kadabra) – Virgil Morgan Jr.</li>



<li><strong>Call Me Goo</strong> (e. Googoo Gaagaa) – Åke Svanstedt</li>



<li><strong>M-m’s Dream</strong> (e. Swan For All) – Henry Graber</li>



<li><strong>Nelson Brite Eagle </strong>(e. Bold Eagle) – Åke Svanstedt</li>



<li><strong>Pioneer Ås</strong> (e. Devious Man) – Anette Lorentzon</li>



<li><strong>Refined</strong> (e. Uncle Peter) – Virgil Morgan Jr.</li>



<li><strong>Swan’s Eye </strong>(e. Swan For All) – Vincent Campolong</li>



<li><strong>Tactical Mounds</strong> (e. Tactical Landing) – Megan Scran</li>



<li><strong>Warrawee Xenia</strong> (e. Walner) – Mark Steacy</li>
</ul>



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



<p class="has-drop-cap">6 Valet av hingst till <strong>Jiggy Jog </strong>(e. Walner-Hot Mess Hanover), 1.08,0*/$3.100.467, lär med största säkerhet bli femfaldige championhingsten <strong>Muscle Hill</strong>, men kombination med Walner är fortsatt ett helt oskrivet kort.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2017/11/musclehillml-617x288.jpg" alt="" class="wp-image-14883"/><figcaption class="wp-element-caption">Muscle Hill vann Hambletonian Stakes och ser ut att bli Jiggy Jogs första partner i aveln. Foto: Stefan Melander/stalltz.se</figcaption></figure>



<p>Walners äldsta barnbarn är födda 2022 och det finns två hästar, varav den ena är svenskfödda stoet <strong>Eirene Face </strong>(e. Mosaique Face-The Grey Queen) och den andra USA-födde <strong>Mattias Hanover</strong> (e. Greenshoe-Ms Spendalot). </p>



<p>Eirene Face finns i träning hos Adrian Kolgjiini och är ostartad. Visat sig på tävlingsbanan har inte heller Mattias Hanover i USA.</p>



<p>Gällande kombinationen Walner-Muscle Hill finns sex hästar, varav fyra är registrerade i år och de två andra 2023. Båda 2023:orna – <strong>Rambo Hanover </strong>(e. Muscle Hill-Riding High) och <strong>Contest</strong> (sto e. Muscle Hill-Dangerous Sky) – bjöds ut på Lexington Selected Yearling Sale. Åke Svanstedt köpte den förstnämnde för 385.000 dollar, medan Contest såldes för 15.000 dollar.</p>



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



<p class="has-drop-cap">7 Idag avgörs den elfte etappen i Grand National du Trot (€90.000) i Saint-Galmier och nu återstår det tre försök innan finalen på Vincennes den 1 december. Grunddistansen idag är 2.625 meter och vinnaren kvitterar ut 40.500 euro.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2024/10/skarmavbild20241015kl.21.12.02.png" alt="" class="wp-image-648292"/></figure>
