<p>Sundbyholmstravet bjuder på travfest i dagarna två. Lördagens V75-omgång innehåller vanliga STL-lopp medan söndagen är kryddad med fyra Breeders Crown-finaler.</p>
<p>Stoeliten (V75-1) inleder omgången och det är ett lopp som verkligen öppnas upp när <strong>Mellby Free</strong> drog en nitlott i spårtombolan och hamnade på bricka åtta. Hon är bra, men från ett sådant här utgångsläge är ingenting givet.</p>
<p>Vi tänder till på två andra hästar som tänkbara spikbud såhär under måndagen. Hemmahästen <strong>That&#8217;s So Clever</strong> (V75-2) står kvar i Klass II trots att han var finalist i Kriteriet. Av senaste segern att döma fortsätter utvecklingskurvan att peka spikrakt uppåt och här kan det vara ledning hela vägen.</p>
<p>Till den positionen är det däremot inte säkert att Katja Melkkos <strong>Vice Versa Diamant</strong> (V75-5) når, men frågan är om det spelar någon roll. Han gick ännu ett topplopp senast i Örebro från omöjligt utgångsläge och nu tror vi på en betydligt mer aktiv Jorma Kontio på alla plan&#8230;</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2021/11/06v75.pdf" target="_blank" rel="noopener">Här kan du ta del av lördagens startlistor till tävlingarna på Sundbyholm.</a></p>
<h2>Avd 1 – Stoeliten, 2.640 meter autostart</h2>
<p>När spårlotten föll som den nu gjorde och <strong>Mellby Free</strong> har lottats till spår åtta så öppnas det här loppet upp markant. Björn Goops sto har varit i toppslag hela hösten, men här är det långt ifrån säkert att hon kommer till på rätt sätt. <strong>Racing Brodda</strong> hamnade i en trött rygg i Sto SM på Åby, men visade fortsatt god form i starten efter i Solänget där hon var tvåa i Diamantstoet trots dubbla tillägg. <strong>Hevin Boko</strong> har varit mer eller mindre bortlottad i de två senaste starterna. Nu har hon öppet läge och då startsnabbheten bättras på under årens lopp är det inte omöjligt att hon kan forceras till tät. Loppets två fyraåriga damer <strong>Global Brilliance</strong> och <strong>Barbro Kronos</strong> har lottats till spår elva respektive tolv och får verkligen slå ur underläge.</p>
<h2>Avd 2 – Klass II, 2.640 meter autostart</h2>
<p>Kriteriefinalisten <strong>That&#8217;s So Clever</strong> bombade hem ett treåringslopp senast på Solvalla på urläckert vis och har en häftig utvecklingskurva. Han står med ännu bättre utgångsläge denna gång, har visat att han tål distansen och står alltjämt kvar i en låg klass. Den här uppgiften ser verkligen passande ut även om det inte är alltför ofta som treåringar vinner mot äldre hästar i STL-sammanhang. <strong>La Verite</strong> är dock en värdig utmanare. Katja Melkko har allmänt bra snurr på stallet och den här hästen är en klar plusvariant. <strong>Fighter Simoni</strong> jagar revansch för galoppmisslyckandet i Örebro och vi tycker att han visat så pass fina takter under sina bästa lopp att han ska kunna hävda sig i Klass II-sammanhang.</p>
<h2>Avd 3 – Gulddivisionen, 1.640 meter autostart</h2>
<figure id="attachment_104140" aria-describedby="caption-attachment-104140" style="width: 617px" class="wp-caption alignright"><a href="https://sulkysport.se/wp-content/uploads/2020/08/brotherbillhuv.jpg"><img class="size-sulky-mellan2 wp-image-104140" src="https://sulkysport.se/wp-content/uploads/2020/08/brotherbillhuv-617x333.jpg" alt="" width="617" height="333" /></a><figcaption id="caption-attachment-104140" class="wp-caption-text">Brother Bill. Foto Mia Törnberg/Sulkysport</figcaption></figure>
<p><strong>Brother Bill</strong> plockade ner Milligan&#8217;s School från utsidan vid deras senaste möte på Solvalla och var kort och gott bara bäst vid det mötet samtidigt som <strong>Disco Volante</strong> inte kunde ta sig förbi trots att han hade gått med i rygg. Här kryddas dock loppet med flera starka toppar och det går inte bara räkna med att Brother Bill löser det här lika enkelt igen. <strong>Handsome Brad</strong> vann Ullbergs Minne på Axevalla och var åter riktigt positiv efter en något sämre insats i STL Open. Skulle han komma förbi <strong>Lawmaker</strong> direkt och man bestämmer sig för att köra i tät så kan hästen sälja sig dyrt på sin högstanivå. <strong>Lucifer Lane</strong> blir svårbedömd efter två månaders uppehåll och här får vi invänta veckans rapporter innan vi känner oss någorlunda trygga kring hur han ska hanteras.</p>
<h2>Avd 4 – Diamantstoet, 2.140 meter voltstart</h2>
<p>Anders Svanstedts <strong>Cash and Carry</strong> har testats mot kulltoppar bland ston vid ett par tillfällen under året och inte gjort bort sig. Hon visade bra form i Örebro, men har därefter varit struken i samband med Breeders Crown-semifinalerna på Solvalla. Har inte det satt sig på formstatusen har hon vettig chans att spåra hem det här loppet. <strong>Navona</strong> har levererat toppinsatser fyra gånger i följd. Robert Bergh hade säkert föredragit framspår, men hon har gått så pass bra att hon måste räknas även här. <strong>Love Eagle</strong> tog sig till final i Finskt Travderby mot pojkar, men fick nöja sig med en tröstpeng som tiondeplacerad den dagen. Formen är konserverad av Solvallasegern senast att döma. Det saknas inte vettiga hästar på tillägg, men vi tycker att den nämnda trion från startvolten ska bli svåra att plocka in 20 meter på.</p>
<h2>Avd 5 – Klass I, 2.140 meter autostart</h2>
<p><strong>Vice Versa Diamant</strong> hade en omöjlig uppgift framför sig senast i Örebro med spår tolv över sprinterdistans. Han gick dock rejält sista 600 meterna som fyra och det såg inte ut som att Jorma Kontio pressade hästen nämnvärt. Nu står han med ett bra, öppet utgångsläge och vi ser framför oss ett scenario där Jorma Kontio inte lämnar något åt slumpen! <strong>Santos de Castella</strong> vann Klass II-finalen i september från ledningen och säljer sig dyrt från den positionen. <strong>Caprioso</strong> har gått jättebra fyra starter i följd, men det är ändå lite svårt att sätta in honom i det här loppet. <strong>Teton Miss Annie</strong> är ett annat formkort som dessutom får Björn Goop bakom sig nu för första gången.</p>
<h2>Avd 6 – Silverdivisionen, 2.140 meter voltstart</h2>
<p><strong>Gardner Shaw</strong> höll helt okej från ledningen i senaste silverloppet på Solänget. Hästen var på väg att öppna riktigt bra från springspår i en av karriärens första starter, men slog på en galopp efter 50 meter och det är så klart väldigt svårt att bedöma hur pass han kan lägga iväg från ett sådant här spår numera. Skulle han hitta till tät kan han i vilket fall bli svårpasserad. <strong>Morotai Degato</strong> gör nästan aldrig en dålig insats. Han är positionssäker och ständigt aktuell när han står med ett bra, öppet startspår. <strong>Svecak Palema</strong> matchats upp mot hingstarna nu, men visade toppform i Örebro och kan gynnas av att inte behöva göra så mycket själv. <strong>Dats So Cool</strong> är bättre än någonsin för dagen och bör ha god chans att få en position som en av de tre främsta hästarna på innerspår. <strong>Van Gogh Z.S.</strong> har klarat av fjärdespår tidigare, men inte öppnat särskilt snabbt.</p>
<h2>Avd 7 – Bronsdivisionen, 2.140 meter autostart</h2>
<p><strong>Global Agreement</strong> tog ner <strong>Arch Lane</strong> från dödens senast i Örebro, men fick ge vika mot Bandido Gar i sista steget. Det var inget att säga något om utan insatsen var verkligen strong. Han frontade från innerspår på Axevalla i juni och har god vinstchans om han lyckas upprepa den saken här. Daniel Wäjersten har en oerhört formstark duo i <strong>Xanthis de Roi</strong> och <strong>Gooner</strong> vilka slutade etta och tvåa i bronsförsöket på Solänget i senaste starten. De är givna aspiranter på nytt. <strong>Eros Zola</strong> låg mer eller mindre sist i fältet hela vägen senast i Örebro, tappade travet allt mer och galopperade utan chans på en framskjuten placeringen 25 meter före mål. Det intrycket gjorde oss tveksamma till hans dagsstatus, men Flemming Jensen brukar aldrig starta hästar så pass tätt som ändå blir fallet nu om han inte känner sig trygg med vart han har sina häst. <strong>Kurri Jari Boko</strong> och <strong>One Kind of Art</strong> har båda redan vunnit bronslopp och <strong>Gogobet Sisu</strong> har återigen rätt kurva på formtrappan.</p>
