
<p class="has-drop-cap">1Hästägare hos Robert Bergh har inhandlat en spännande &#8221;lördagshäst&#8221;. Det handlar om femårige <strong>Il Forte </strong>(e. One Too Many) 1.11,3ak/517.000 kr som skiftar stall efter att funnits hos sin uppfödare Jarl Olsson hela tävlingskarriären igenom.<br>Under fjolåret var hästen måletta i såväl försök som final av Klass II under våren, men fråntogs de segrarna på grund av att ha testat positivt för metylprednisolon.<br>Under senhösten togs viss revansch då hästen åter vann ett Klass II-försök i Kalmar och i år har det blivit två vardagssegrar på sju starter.<br>– Det är (Roland, red.anm.) Wikstén i Boden som köpt hästen. Jag är 60 år gammal nu och ska minska på hästantalet och när man har en bra häst så blir det en hel del resande. Jag fick ett hyfsat bud och det gick rätt så snabbt allting. Hästen lämnade stallet i torsdags, säger Jarl Olsson.</p>



<p><strong>Vad tar du ut som höjdpunkt under tävlingskarriären?</strong><br>– Jag kan inte lyfta något speciellt utan det är ett helhetsintryck. Hästen har skänkt mig mycket glädje och jag hoppas och tror att de nya ägarna ska få lika roligt med hästen för Robert Bergh är en duktig tränare som säkert har alla möjligheter att utveckla hästen ytterligare, säger Jarl Olsson.</p>



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



<p class="has-drop-cap">2De är två av de stora avelshingstarna genom åren på svensk mark. Både <strong>Count&#8217;s Pride</strong> (e. Speedy Count) och <strong>Quick Pay </strong>(e. Star&#8217;s Pride) utsågs till Elithingstar för sina gärningar i aveln hos Ingmar Andersson på Lassagården. Ikväll på Åbytravet avgörs varsitt treåringslopp i hingstarnas namn, lopp som körts sedan slutet av 1990-talet.</p>



<p>Och nog finns det fog att minnas och hylla dessa giganter. Quick Pay fick bland sina 1.117 svenskregistrerade avkommor den främste av alla, nämligen Sveriges vinstrikaste travare genom tiderna <strong>Victory Tilly</strong>! Denne sprang in 37,7 av Quick Pays totalsiffra 226 miljoner kronor. Victory Tilly kom ur Quick Pays 17:e och näst sista kull. Redan i den första fanns Elitloppsvinnaren The Onion.</p>



<p>Count&#8217;s Pride fick 1.404 svenskfödda avkommor som sprang in drygt 184 miljoner kronor med Derbyvinnaren <strong>Jet Ribb</strong> som vinstrikaste avkomma. Nämnas kan också Triple Crown-vinnaren <strong>Gaston Pride</strong> och Europaderbyvinnaren <strong>Clash Hammering</strong>.</p>



<p>Quick Pay-Pokalen, som ligger utanför V86-kupongen, är utskrivet för de treåriga stona och det har lockat talanger födda i flera länder. Som Jerry Riordans nybakade finska Stokriterievinnare <strong>Lightning Stride </strong>(e. Twister Bi), Johan Untersteiners tyska Sierra S. (e. Father Patrick), Stefan P Petterssons svenska nästanmiljonärska <strong>Kitty Hawk</strong> (e. Fourth Dimension) och framför allt Reijo Liljendahls italienska ämne <strong>Eteria</strong> (e. Tactical Landing). Eteria vann försök till långa E3 som megafavorit, men fick strykas från finalen.<br>I Count&#8217;s Pride-Pokalen för hingstar och valacker bjuds en annan toppitalienare från Liljendahls stall.<strong> Epsom As </strong>(e. Muscle Mass) vann Breeders Course-finalen under Elitloppshelgen och har varit trea respektive fyra i sommarens två E3-finaler.</p>



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



<p class="has-drop-cap">3Åby (första start 18.27) står för grannlåten i kvällens expresstrav med V86 som delas med Solvalla (start 18.15) med de båda treåringsloppen, men godbitar saknas inte på huvudstadsbanan heller.</p>



<p>Ett bonuslopp i Breeders Course-serien för treåringar med högst 180.000 kronor på kontot bjuder bland annat på ett möte mellan två obesegrade ungdomar, spetsat med ytterligare spännande namn.</p>



<p>Timo Nurmos-tränade<strong> Our Pride </strong>(e. Maharajah) har inlett med tre segrar och en i Gävle när han i femte starten nu kliver ut på hemmabanan Solvalla. Our Pride har tagit tre av segrarna från ledningen och drog innerspår bakom bilen i kvällens lopp. Desto tuffare utgångsläge har Daniel Wäjerstens <strong>Competivo</strong> (e. Bird Parker), som närmast kommer från inponerande seger på 1.14,9a/2.140 meter på Bergsåker.</p>



<p>Loppet blir också ett av få test över lång distans för de svenskfödda treåringarna inför kvalen till Svenskt Travkriterium på Solvalla den 1 oktober. Our Pride är en av kullens hästar som redan testad förutsättningarna med segern i ett treåringslopp i Gävle i senaste starten.</p>



<p>Hittills i år är Roger Walmann-tränade <strong>S.G.Dracarys </strong>(e. Bold Eagle) snabbaste vinnaren, då han travade 1.14,4a/2.609 meter vid seger i Juliloppet i Örebro.</p>



<p>I ett av försöken i Solvallaserien dyker en annan obesegrad travare upp. Timo Nurmos plockar ut finskfödde fyraåringen<strong> Live To Tell</strong> (e. Villiam), som efter fyra starter fortfarande inte vet hur det känns att förlora.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/09/06v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till onsdagens tävlingar.</a></p>



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



<p class="has-drop-cap">4Det tredje av fyra försök till Breeders Course för tvååringar avgörs på Åby ikväll och blott sex hästar gör upp om tre finalplatser på Jägersro den 4 oktober med 700.000 kronor till vinnaren.</p>



<p>Vinnarna av de två tidigare uttagningsloppen är <strong>Feldenkrais Pal </strong>(e. Trixton-Tuscania Pal), som vann övertygande tillsammans med Micha Brouwer på 1.14,5a/1.609 meter i nederländska Wolvega, och Fredrik Wallin-tränade <strong>Chapter One</strong> (e. Chapter Seven-Etta Am), vars 1.16,9a/1.640 meter räckte till enkel seger på Solvalla förra veckan med Magnus A Djuse.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/chapteronemadm230830adamstromstalltz-617x382.jpg" alt="" class="wp-image-490506"/><figcaption class="wp-element-caption">Chapter One vinner för Magnus A Djuse. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Åbys uttagningslopp innehåller blott två svenskfödda hästar – Anders Svanstedts <strong>V.Bucks </strong>(e. Brillantissime) och Per Nordströms <strong>Duke</strong> (e. Maharajah) – som båda kommer från andraplatser i karriärens startskede. Nu ställs de mot tre italienska tvååringar och en norskfödd. Nordström tränar även norske <strong>Cogburn</strong> (e. Googoo Gaagaa), medan Magnus Dahlén har en duo med Elitloppsvinnaren <strong>Ringostarr Treb </strong>som pappa, <strong>Fiammetta Bar </strong>och <strong>Frisbee K.B.Font</strong>. Startfältet kompletteras med den enda tvååringen som vunnit lopp, Gennaro Casillos<strong> Federica Jet </strong>(e. Maharajah).</p>



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



<p class="has-drop-cap">5 Efter att övertygat under vintermeetinget och bland annat vunnit Prix de Selection (€240.000) bjöds <strong>Horsy Dream </strong>(e. Scipion du Goutier) in till Elitloppet, men till det loppet lämnade tränaren Pierre Belloche ett sent återbud efter en mindre lyckad vår.</p>



<p>I början av augusti var hästen åter tillbaka på tävlingsbanan och vann ett vardagslopp i Graignes, men idag spänns åter bågen.</p>



<p>Sexåringen körs av Eric Raffin i Grupp II-klassade Grand Prix Federation Regionale du Nord (€120.000) i La Capelle (första start kl. 13.50) vilket även innehåller toppnamn som <strong>Elie de Beaufour </strong>(e. Royal Dream), <strong>Hussard du Landret </strong>(e. Bird Parker) och <strong>Happy Valley</strong> (e. Royal Dream).<br>Loppets blågula inslag är Christoffer Eriksson-tränade <strong>Self Explosive</strong> (e. Explosive Matter) som startar i andra ledet tillsammans med Alexis Prat.</p>



<p>I La Capelle startar även svenskfödde <strong>King Cole</strong> (e. Maharajah) i Prix du Credit Agricole Nord-Est (€35.000), Ron Kuipers <strong>Flash Back du Nord</strong> (e. Coktail Jet) i Prix Groupe Lanie (€6.000) och Tomas Malmqvists <strong>Koelho de Nappes</strong> (e. Charly du Noyer) i Prix Com de Com Thierache du Centre (€30.000).</p>



<p><a href="https://sulkysport.se/trav-och-galopp/la-capelle-2023-09-06/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i La Capelle.</a></p>



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



<p class="has-drop-cap">6 Face Time Bourbon-dottern <strong>Sparkling Tile</strong>, 1.13,5ak/166.928 kr var den näst dyraste hästen som såldes på Travera-auktionen för två veckor sedan då hon klubbades bort för 230.000 kronor.</p>



<p>Nu står det klart att stoet tar vägen från Mattias Djuse till Per Lennartsson och det är På Stället KB i Stockholm som äger stoet sedan den 1 september.</p>



<p>Sparkling Tile vann lopp på amerikansk mark som tvååring, men slutade oplacerad i båda starterna hos Mattias Djuse denna sommar.</p>



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



<p class="has-drop-cap">7 Jörgen Westholm-tränade tillika ägde <strong>Holster</strong> (e. Bird Parker) vann tisdagens amatörlopp på gräsbanan i Dieppe.<br>Loppet var namngivet titeln Prix Camille Pissaro (€5.500) och körande Ann Kristin Rasmussen kunde räkna hem sin femte kuskseger på fransk mark då hon styrde hästen till vinsten värd 2.475 euro på 1.23,9/2.575 meter.</p>

Fokustema
Morgonsvepet
Läs senare
V75-vinnare såld
Om en V75-vinnare som byter regi efter försäljning, svenskt hopp i franskt storlopp och kvällens högklassiga sport på Solvalla samt Åby kan du läsa i veckans tredje morgonsvep.
