<div class="fts-jal-fb-header"><h1 ><a href="https://www.facebook.com/Fsv08Bissingen/" target="_blank" rel="noreferrer">FSV 08 Bissingen</a></h1></div><div class="fts-jal-fb-group-display fts-simple-fb-wrapper feed_dynamic_classavtpucgjxv_page "><div class='fts-fb-photo-post-wrap fts-jal-single-fb-post' ><div  class="fts-jal-fb-right-wrap"><div class="fts-jal-fb-top-wrap "><div class="fts-jal-fb-user-thumb"><a href="https://www.facebook.com/Fsv08Bissingen" target="_blank" rel="noreferrer"><img border="0" alt="FSV 08 Bissingen" src="https://graph.facebook.com/Fsv08Bissingen/picture"/></a></div><span class="fts-jal-fb-user-name"><a href="https://www.facebook.com/Fsv08Bissingen" target="_blank" rel="noreferrer">FSV 08 Bissingen</a></span><span class="fts-jal-fb-post-time"> </span><div class="fts-clear"></div><div class="fts-jal-fb-message">MEDIN BULIC VERLÄSST 08<br />
<br />
Medin Bulic verlässt die Nullachter und wechselt mit sofortiger Wirkung zum NK Croatia Bietigheim.<br />
<br />
In der Winterpause gibt es einige Veränderungen im Kader der Bruchwaldelf. Medin Bulic verlässt das Team und wechselt mit sofortiger Wirkung zum NK Croatia Bietigheim. Der Abwehrspieler hat die Jugendteams der Nullachter durchlaufen und nach einem Jahr in der U23 den Sprung in die Bruchwaldelf geschafft. In der Vorrunde ist Bulic sogar als Stammspieler aufgelaufen. Gegen Ende der Rückrunde musste er sich jedoch mit einer hartnäckigen Muskelverletzung befassen.<br />
<br />
Dr. Alexander Rossmann, Vorstand der Nullachter, fasst den Wechsel wie folgt zusammen: “Medin ist ein Musterbeispiel für den eingeschlagenen Weg bei Nullacht. Er hat mit viel Talent und Disziplin den Weg von der Jugend, über die U23 bis in die Oberliga geschafft. Eigentlich sahen wir hier noch sehr viel Potential für mehr. Allerdings startet Medin nun mit seinem Studium und daher sind wir seinem Wunsch nach Veränderung entgegen gekommen. Wir wünschen Medin für den weiteren Weg alles Gute und bedanken uns beim NK Croatia Bietigheim für die reibungslose Abwicklung des Transfers”.<br />
<br />
<a href="https://www.facebook.com/hashtag/DankeMedin" target="_blank" rel="noreferrer">#DankeMedin</a> – alles Gute für die Zukunft!<br />
<br />
Bei den Nullachtern steht derweil die Planung der Rückrunde auf dem Programm. Markus Lang startet die Vorbereitung auf die Rückrunde mit dem Trainingsauftakt am 23.1.<div class="fts-clear"></div></div></div><div class="fts-jal-fb-link-wrap fts-album-photos-wrap"><a href="https://www.facebook.com/photo.php?fbid=1043408093266467&#038;set=a.921728725434405&#038;type=3" target="_blank" rel="noreferrer" class="fts-jal-fb-picture"><img border="0" alt="FSV 08 Bissingen" src="https://scontent-fra5-2.xx.fbcdn.net/v/t39.30808-6/326082683_977162836588175_525036070057585611_n.jpg?stp=dst-jpg_p720x720&#038;_nc_cat=110&#038;ccb=1-7&#038;_nc_sid=8bfeb9&#038;_nc_ohc=UxmAR9BVS3cAX9JowVI&#038;_nc_ht=scontent-fra5-2.xx&#038;edm=ALdPpPkEAAAA&#038;oh=00_AfAgjk45_wOfgdojUVZsq64qFInkL7r7QCTT1CmBygMl3A&#038;oe=63D352F7"/></a><div class="slicker-facebook-album-photoshadow"></div><div class="fts-clear"></div></div><div class="fts-clear"></div></div><div class="fts-likes-shares-etc-wrap"><div class="fts-share-wrap"><a href="javascript:;" class="ft-gallery-link-popup" title="Social Share Options">
<svg viewBox="0 0 24 24" aria-hidden="true" class="svg-inline--fa r-4qtqp9 r-yyyyoo r-50lct3 r-dnmrzs r-bnwqim r-1plcrui r-lrvibr r-1srniue"><g><path d="M17.53 7.47l-5-5c-.293-.293-.768-.293-1.06 0l-5 5c-.294.293-.294.768 0 1.06s.767.294 1.06 0l3.72-3.72V15c0 .414.336.75.75.75s.75-.336.75-.75V4.81l3.72 3.72c.146.147.338.22.53.22s.384-.072.53-.22c.293-.293.293-.767 0-1.06z"></path><path d="M19.708 21.944H4.292C3.028 21.944 2 20.916 2 19.652V14c0-.414.336-.75.75-.75s.75.336.75.75v5.652c0 .437.355.792.792.792h15.416c.437 0 .792-.355.792-.792V14c0-.414.336-.75.75-.75s.75.336.75.75v5.652c0 1.264-1.028 2.292-2.292 2.292z"></path></g></svg></a><div class="ft-gallery-share-wrap"><a href="https://www.facebook.com/sharer/sharer.php?u=https://www.facebook.com/photo.php?fbid=1043408093266467&amp;set=a.921728725434405&amp;type=3" target="_blank" rel="noreferrer" class="ft-galleryfacebook-icon" title="Share this post on Facebook"><i class="fa fa-facebook-square"></i></a><a href="https://twitter.com/intent/tweet?text=https://www.facebook.com/photo.php?fbid=1043408093266467&amp;set=a.921728725434405&amp;type=3+MEDIN BULIC VERLÄSST 08

Medin Bulic verlässt die Nullachter und wechselt mit sofortiger Wirkung zum NK Croatia Bietigheim.

In der Winterpause gibt es einige Veränderungen im Kader der Bruchwaldelf. Medin Bulic verlässt das Team und wechselt mit sofortiger Wirkung zum NK Croatia Bietigheim. Der Abwehrspieler hat die Jugendteams der Nullachter durchlaufen und nach einem Jahr in der U23 den Sprung in die Bruchwaldelf geschafft. In der Vorrunde ist Bulic sogar als Stammspieler aufgelaufen. Gegen Ende der Rückrunde musste er sich jedoch mit einer hartnäckigen Muskelverletzung befassen.

Dr. Alexander Rossmann, Vorstand der Nullachter, fasst den Wechsel wie folgt zusammen: “Medin ist ein Musterbeispiel für den eingeschlagenen Weg bei Nullacht. Er hat mit viel Talent und Disziplin den Weg von der Jugend, über die U23 bis in die Oberliga geschafft. Eigentlich sahen wir hier noch sehr viel Potential für mehr. Allerdings startet Medin nun mit seinem Studium und daher sind wir seinem Wunsch nach Veränderung entgegen gekommen. Wir wünschen Medin für den weiteren Weg alles Gute und bedanken uns beim NK Croatia Bietigheim für die reibungslose Abwicklung des Transfers”.

#DankeMedin – alles Gute für die Zukunft!

Bei den Nullachtern steht derweil die Planung der Rückrunde auf dem Programm. Markus Lang startet die Vorbereitung auf die Rückrunde mit dem Trainingsauftakt am 23.1." target="_blank" rel="noreferrer" class="ft-gallerytwitter-icon" title="Share this post on Twitter"><i class="fa fa-twitter"></i></a><a href="https://plus.google.com/share?url=https://www.facebook.com/photo.php?fbid=1043408093266467&amp;set=a.921728725434405&amp;type=3" target="_blank" rel="noreferrer" class="ft-gallerygoogle-icon" title="Share this post on Google"><i class="fa fa-google-plus"></i></a><a href="https://www.linkedin.com/shareArticle?mini=true&amp;url=https://www.facebook.com/photo.php?fbid=1043408093266467&amp;set=a.921728725434405&amp;type=3" target="_blank" rel="noreferrer" class="ft-gallerylinkedin-icon" title="Share this post on Linkedin"><i class="fa fa-linkedin"></i></a><a href="mailto:?subject=Shared Link&amp;body=https://www.facebook.com/photo.php?fbid=1043408093266467&amp;set=a.921728725434405&amp;type=3 MEDIN BULIC VERLÄSST 08

Medin Bulic verlässt die Nullachter und wechselt mit sofortiger Wirkung zum NK Croatia Bietigheim.

In der Winterpause gibt es einige Veränderungen im Kader der Bruchwaldelf. Medin Bulic verlässt das Team und wechselt mit sofortiger Wirkung zum NK Croatia Bietigheim. Der Abwehrspieler hat die Jugendteams der Nullachter durchlaufen und nach einem Jahr in der U23 den Sprung in die Bruchwaldelf geschafft. In der Vorrunde ist Bulic sogar als Stammspieler aufgelaufen. Gegen Ende der Rückrunde musste er sich jedoch mit einer hartnäckigen Muskelverletzung befassen.

Dr. Alexander Rossmann, Vorstand der Nullachter, fasst den Wechsel wie folgt zusammen: “Medin ist ein Musterbeispiel für den eingeschlagenen Weg bei Nullacht. Er hat mit viel Talent und Disziplin den Weg von der Jugend, über die U23 bis in die Oberliga geschafft. Eigentlich sahen wir hier noch sehr viel Potential für mehr. Allerdings startet Medin nun mit seinem Studium und daher sind wir seinem Wunsch nach Veränderung entgegen gekommen. Wir wünschen Medin für den weiteren Weg alles Gute und bedanken uns beim NK Croatia Bietigheim für die reibungslose Abwicklung des Transfers”.

#DankeMedin – alles Gute für die Zukunft!

Bei den Nullachtern steht derweil die Planung der Rückrunde auf dem Programm. Markus Lang startet die Vorbereitung auf die Rückrunde mit dem Trainingsauftakt am 23.1." target="_blank" rel="noreferrer" class="ft-galleryemail-icon" title="Share this post in your email"><i class="fa fa-envelope"></i></a></div></div><a href="https://www.facebook.com/photo.php?fbid=1043408093266467&#038;set=a.921728725434405&#038;type=3" target="_blank" rel="noreferrer" class="fts-jal-fb-see-more">   &nbsp;&nbsp;&nbsp;Zeige auf Facebook</a></div><div class="fts-clear"></div></div><div class='fts-fb-photo-post-wrap fts-jal-single-fb-post' ><div  class="fts-jal-fb-right-wrap"><div class="fts-jal-fb-top-wrap "><div class="fts-jal-fb-user-thumb"><a href="https://www.facebook.com/Fsv08Bissingen" target="_blank" rel="noreferrer"><img border="0" alt="FSV 08 Bissingen" src="https://graph.facebook.com/Fsv08Bissingen/picture"/></a></div><span class="fts-jal-fb-user-name"><a href="https://www.facebook.com/Fsv08Bissingen" target="_blank" rel="noreferrer">FSV 08 Bissingen</a> fühlt sich fantastisch.</span><span class="fts-jal-fb-post-time"> </span><div class="fts-clear"></div><div class="fts-jal-fb-message">MANFRED BLEILE ÜBERNIMMT MARKETING BEI NULLACHT<br />
<br />
Sponsoring und Öffentlichkeitsarbeit sind auch bei Amateursportklubs relevanter denn je. Der Fußball-Sport-Verein 08 Bietigheim-Bissingen hat auf seinem engagierten Weg zu mehr Professionalität auch diesbezüglich einen Schritt in die Zukunft gemacht und mit Manfred Bleile einen Marketing-Chef gewonnen.<br />
<br />
Der 57-Jährige waschechte Ludwigsburger und Kaufmann für Bürokommunikation mit Fachhochschulreife Wirtschaft ist Expansionsleiter bei der RENO Schuh GmbH und war beim SGV Freiberg Fußball kaufmännischer Leiter. Seine Schwerpunkte waren dort vor allem Sponsoring, Marketing und die Betreuung und Unterstützung des Medien-Teams bei Social-Media-Beiträgen/ Aktionen, ab und zu als Operator beim Live-Streaming, Ticket-Online, Hospitality, das Erstellen von Layouts und Grafiken für alle Bereiche. Grafikdesign ist sein Hobby.<br />
<br />
Nachdem Bleile eineinhalb Jahre in Österreich die Marketingabteilung seines Arbeitgebers geführt hatte, konnte er in diesem Bereich Eindrücke sammeln und hatte sich nachfolgend in sämtlichen Hochschulkursen (Adobe Photoshop, Indesign, Illustator) sowie für mehrere Fachvorträge zum Thema Gestaltung eingetragen.<br />
<br />
Ab sofort ist Manne für Nullacht unterwegs. Siehe hier das gesamt Interview <a href="https://fsv08.de/manne-bleile-marketing-chef/" target="_blank" rel="noreferrer">https://fsv08.de/manne-bleile-marketing-chef/</a><br />
<br />
Herzlich Willkommen Manne!<div class="fts-clear"></div></div></div><div class="fts-jal-fb-link-wrap fts-album-photos-wrap"><a href="https://www.facebook.com/photo.php?fbid=1038799687060641&#038;set=a.921728715434406&#038;type=3" target="_blank" rel="noreferrer" class="fts-jal-fb-picture"><img border="0" alt="FSV 08 Bissingen" src="https://scontent-fra5-2.xx.fbcdn.net/v/t39.30808-6/323133398_1159713434679134_5568119294631449664_n.jpg?stp=dst-jpg_p720x720&#038;_nc_cat=109&#038;ccb=1-7&#038;_nc_sid=730e14&#038;_nc_ohc=jRrESoByje4AX-tqxRO&#038;_nc_oc=AQkegFXHX35hjlyANhnDlbPkGH85c72uA6mZPARAjfiowRL0qXXBjQ1D0Bn8BP8Zv8E&#038;_nc_ht=scontent-fra5-2.xx&#038;edm=ALdPpPkEAAAA&#038;oh=00_AfD9ycl_EpG891zmkzsVMoxkkxbITKcz2-rWoHgpZFb8Zw&#038;oe=63D2D9F3"/></a><div class="slicker-facebook-album-photoshadow"></div><div class="fts-clear"></div></div><div class="fts-clear"></div></div><div class="fts-likes-shares-etc-wrap"><div class="fts-share-wrap"><a href="javascript:;" class="ft-gallery-link-popup" title="Social Share Options">
<svg viewBox="0 0 24 24" aria-hidden="true" class="svg-inline--fa r-4qtqp9 r-yyyyoo r-50lct3 r-dnmrzs r-bnwqim r-1plcrui r-lrvibr r-1srniue"><g><path d="M17.53 7.47l-5-5c-.293-.293-.768-.293-1.06 0l-5 5c-.294.293-.294.768 0 1.06s.767.294 1.06 0l3.72-3.72V15c0 .414.336.75.75.75s.75-.336.75-.75V4.81l3.72 3.72c.146.147.338.22.53.22s.384-.072.53-.22c.293-.293.293-.767 0-1.06z"></path><path d="M19.708 21.944H4.292C3.028 21.944 2 20.916 2 19.652V14c0-.414.336-.75.75-.75s.75.336.75.75v5.652c0 .437.355.792.792.792h15.416c.437 0 .792-.355.792-.792V14c0-.414.336-.75.75-.75s.75.336.75.75v5.652c0 1.264-1.028 2.292-2.292 2.292z"></path></g></svg></a><div class="ft-gallery-share-wrap"><a href="https://www.facebook.com/sharer/sharer.php?u=https://www.facebook.com/photo.php?fbid=1038799687060641&amp;set=a.921728715434406&amp;type=3" target="_blank" rel="noreferrer" class="ft-galleryfacebook-icon" title="Share this post on Facebook"><i class="fa fa-facebook-square"></i></a><a href="https://twitter.com/intent/tweet?text=https://www.facebook.com/photo.php?fbid=1038799687060641&amp;set=a.921728715434406&amp;type=3+MANFRED BLEILE ÜBERNIMMT MARKETING BEI NULLACHT

Sponsoring und Öffentlichkeitsarbeit sind auch bei Amateursportklubs relevanter denn je. Der Fußball-Sport-Verein 08 Bietigheim-Bissingen hat auf seinem engagierten Weg zu mehr Professionalität auch diesbezüglich einen Schritt in die Zukunft gemacht und mit Manfred Bleile einen Marketing-Chef gewonnen.

Der 57-Jährige waschechte Ludwigsburger und Kaufmann für Bürokommunikation mit Fachhochschulreife Wirtschaft ist Expansionsleiter bei der RENO Schuh GmbH und war beim SGV Freiberg Fußball kaufmännischer Leiter. Seine Schwerpunkte waren dort vor allem Sponsoring, Marketing und die Betreuung und Unterstützung des Medien-Teams bei Social-Media-Beiträgen/ Aktionen, ab und zu als Operator beim Live-Streaming, Ticket-Online, Hospitality, das Erstellen von Layouts und Grafiken für alle Bereiche. Grafikdesign ist sein Hobby.

Nachdem Bleile eineinhalb Jahre in Österreich die Marketingabteilung seines Arbeitgebers geführt hatte, konnte er in diesem Bereich Eindrücke sammeln und hatte sich nachfolgend in sämtlichen Hochschulkursen (Adobe Photoshop, Indesign, Illustator) sowie für mehrere Fachvorträge zum Thema Gestaltung eingetragen.

Ab sofort ist Manne für Nullacht unterwegs. Siehe hier das gesamt Interview https://fsv08.de/manne-bleile-marketing-chef/

Herzlich Willkommen Manne!" target="_blank" rel="noreferrer" class="ft-gallerytwitter-icon" title="Share this post on Twitter"><i class="fa fa-twitter"></i></a><a href="https://plus.google.com/share?url=https://www.facebook.com/photo.php?fbid=1038799687060641&amp;set=a.921728715434406&amp;type=3" target="_blank" rel="noreferrer" class="ft-gallerygoogle-icon" title="Share this post on Google"><i class="fa fa-google-plus"></i></a><a href="https://www.linkedin.com/shareArticle?mini=true&amp;url=https://www.facebook.com/photo.php?fbid=1038799687060641&amp;set=a.921728715434406&amp;type=3" target="_blank" rel="noreferrer" class="ft-gallerylinkedin-icon" title="Share this post on Linkedin"><i class="fa fa-linkedin"></i></a><a href="mailto:?subject=Shared Link&amp;body=https://www.facebook.com/photo.php?fbid=1038799687060641&amp;set=a.921728715434406&amp;type=3 MANFRED BLEILE ÜBERNIMMT MARKETING BEI NULLACHT

Sponsoring und Öffentlichkeitsarbeit sind auch bei Amateursportklubs relevanter denn je. Der Fußball-Sport-Verein 08 Bietigheim-Bissingen hat auf seinem engagierten Weg zu mehr Professionalität auch diesbezüglich einen Schritt in die Zukunft gemacht und mit Manfred Bleile einen Marketing-Chef gewonnen.

Der 57-Jährige waschechte Ludwigsburger und Kaufmann für Bürokommunikation mit Fachhochschulreife Wirtschaft ist Expansionsleiter bei der RENO Schuh GmbH und war beim SGV Freiberg Fußball kaufmännischer Leiter. Seine Schwerpunkte waren dort vor allem Sponsoring, Marketing und die Betreuung und Unterstützung des Medien-Teams bei Social-Media-Beiträgen/ Aktionen, ab und zu als Operator beim Live-Streaming, Ticket-Online, Hospitality, das Erstellen von Layouts und Grafiken für alle Bereiche. Grafikdesign ist sein Hobby.

Nachdem Bleile eineinhalb Jahre in Österreich die Marketingabteilung seines Arbeitgebers geführt hatte, konnte er in diesem Bereich Eindrücke sammeln und hatte sich nachfolgend in sämtlichen Hochschulkursen (Adobe Photoshop, Indesign, Illustator) sowie für mehrere Fachvorträge zum Thema Gestaltung eingetragen.

Ab sofort ist Manne für Nullacht unterwegs. Siehe hier das gesamt Interview https://fsv08.de/manne-bleile-marketing-chef/

Herzlich Willkommen Manne!" target="_blank" rel="noreferrer" class="ft-galleryemail-icon" title="Share this post in your email"><i class="fa fa-envelope"></i></a></div></div><a href="https://www.facebook.com/photo.php?fbid=1038799687060641&#038;set=a.921728715434406&#038;type=3" target="_blank" rel="noreferrer" class="fts-jal-fb-see-more">   &nbsp;&nbsp;&nbsp;Zeige auf Facebook</a></div><div class="fts-clear"></div></div><div class='fts-fb-photo-post-wrap fts-jal-single-fb-post' ><div  class="fts-jal-fb-right-wrap"><div class="fts-jal-fb-top-wrap "><div class="fts-jal-fb-user-thumb"><a href="https://www.facebook.com/Fsv08Bissingen" target="_blank" rel="noreferrer"><img border="0" alt="FSV 08 Bissingen" src="https://graph.facebook.com/Fsv08Bissingen/picture"/></a></div><span class="fts-jal-fb-user-name"><a href="https://www.facebook.com/Fsv08Bissingen" target="_blank" rel="noreferrer">FSV 08 Bissingen</a> fühlt sich stolz.</span><span class="fts-jal-fb-post-time"> </span><div class="fts-clear"></div><div class="fts-jal-fb-message">MARIO KLOTZ WECHSELT NACH BACKNANG<br />
<br />
Mario Klotz wird Chef-Coach der TSG Backnang Fußball. Der bisherige Co-Trainer der Bruchwaldelf wechselt mit sofortiger Wirkung zum Ligakonkurrenten.<br />
<br />
Damit vollzieht der ehemalige 08-Spieler einen weiteren Karriereschritt als Trainer. Am Bruchwald hat Klotz als Co-Trainer der U23 begonnen, Trainerlizensierungen durchlaufen und danach das Co-Traineramt der Oberligamannschaft übernommen. Nun folgt der Wechsel auf den Chefposten in Backnang.<br />
<br />
"Vielen Dank für die geile Zeit", mit diesen Worten verabschiedete sich der allseits Klotzer genannte Coach bereits am Mittwoch von der Mannschaft. "Ich denke zurück an unser Trainingslager am Walchsee, an viele starke und unvergessliche Spiele, harte Trainingseinheiten, an Emotionen und die vielen Glücksgefühle, welche wir gemeinsam erleben durften. Das alles und noch vieles mehr bringe ich mit euch in Verbindung".<br />
<br />
Mario Klotz hatte zur Saison 2019/2020 das Co-Trainer Amt bei der U23 der Nullachter übernommen und ist in der Folgesaison als Co-Trainer von Markus Lang bei der Bruchwaldelf eingestiegen. Nun folgt der nächste Schritte mit dem Wechsel als Chef-Trainer zur TSG Backnang.<br />
<br />
Der sportliche Leiter des Oberliga-Teams Oliver Dense kommentiert den Wechsel wie folgt: "Mario Klotz ist kurz vor Weihnachten mit der Bitte an uns heran getreten seinen Vertrag aufzulösen, da er Cheftrainer in Backnang werden möchte. Diese Bitte kam für uns sehr überraschend und war vom Zeitpunkt natürlich sehr unglücklich gewählt. Trotzdem wollten wir ihm diese Chance nicht verwehren, da dies auch einen schlüssigen Weg von Mario darstellt und unserem Aufbau der Ausbildung entspricht. So konnten wir uns zügig mit der TSG und Mario auf eine Freigabe einigen.<br />
<br />
Eine Nachfolgelösung ist zumindest bis zum Ende der aktuellen Saison in Sicht. "Natürlich war zum jetzigen Zeitpunkt unsere Wunschlösung für einen neuen Co-Trainer in der Kürze der Zeit nicht zu realisieren. Deshalb sind wir sehr froh, dass sich unser Teammanager Mario Di Biccari bereit erklärt hat, diese Rolle übergangsweise bis zum Sommer in Doppelfunktion zu übernehmen. Mario ist als Ex Profi und ehemaliger 08 Spieler eine ideale Lösung, er kennt die Mannschaft das Umfeld und benötigt keine Kennenlernphase. Daher geht unser Dank an Mario Di Biccari für seine Einsatzbereitschaft", führt Dense weiter aus.<br />
<br />
Mario Klotz danken wir für seine Zeit bei Nullacht. Wir verlieren mit ihm einen klasse Typen. Klotzer hat sich immer völlig mit dem Verein identifiziert, hatte stets eine engen Draht zum Team und wird sicherlich ein Stück Nullacht in sich behalten, da er bereits als Spieler bei uns aktiv war. Wir sind uns sicher dass er seinen Weg machen wird, wünschen ihm dafür alles Gute, viel Erfolg und freuen uns stets auf ein Wiedersehen.<br />
<br />
Hier geht es zur kompletten Meldung <a href="https://fsv08.de/mario-klotz-wechselt-nach-backnang/" target="_blank" rel="noreferrer">https://fsv08.de/mario-klotz-wechselt-nach-backnang/</a><div class="fts-clear"></div></div></div><div class="fts-jal-fb-link-wrap fts-album-photos-wrap"><a href="https://www.facebook.com/photo.php?fbid=1038618447078765&#038;set=a.921728715434406&#038;type=3" target="_blank" rel="noreferrer" class="fts-jal-fb-picture"><img border="0" alt="FSV 08 Bissingen" src="https://scontent-fra5-2.xx.fbcdn.net/v/t39.30808-6/323018709_509892474459460_2210969487049292093_n.jpg?_nc_cat=101&#038;ccb=1-7&#038;_nc_sid=730e14&#038;_nc_ohc=tsSaTz6CMXYAX83Xvfa&#038;_nc_ht=scontent-fra5-2.xx&#038;edm=ALdPpPkEAAAA&#038;oh=00_AfAfR9-YCgSAVvwp687QNzkp1v2HdAaS4CTBxeKFNtTP4Q&#038;oe=63D40BE8"/></a><div class="slicker-facebook-album-photoshadow"></div><div class="fts-clear"></div></div><div class="fts-clear"></div></div><div class="fts-likes-shares-etc-wrap"><div class="fts-share-wrap"><a href="javascript:;" class="ft-gallery-link-popup" title="Social Share Options">
<svg viewBox="0 0 24 24" aria-hidden="true" class="svg-inline--fa r-4qtqp9 r-yyyyoo r-50lct3 r-dnmrzs r-bnwqim r-1plcrui r-lrvibr r-1srniue"><g><path d="M17.53 7.47l-5-5c-.293-.293-.768-.293-1.06 0l-5 5c-.294.293-.294.768 0 1.06s.767.294 1.06 0l3.72-3.72V15c0 .414.336.75.75.75s.75-.336.75-.75V4.81l3.72 3.72c.146.147.338.22.53.22s.384-.072.53-.22c.293-.293.293-.767 0-1.06z"></path><path d="M19.708 21.944H4.292C3.028 21.944 2 20.916 2 19.652V14c0-.414.336-.75.75-.75s.75.336.75.75v5.652c0 .437.355.792.792.792h15.416c.437 0 .792-.355.792-.792V14c0-.414.336-.75.75-.75s.75.336.75.75v5.652c0 1.264-1.028 2.292-2.292 2.292z"></path></g></svg></a><div class="ft-gallery-share-wrap"><a href="https://www.facebook.com/sharer/sharer.php?u=https://www.facebook.com/photo.php?fbid=1038618447078765&amp;set=a.921728715434406&amp;type=3" target="_blank" rel="noreferrer" class="ft-galleryfacebook-icon" title="Share this post on Facebook"><i class="fa fa-facebook-square"></i></a><a href="https://twitter.com/intent/tweet?text=https://www.facebook.com/photo.php?fbid=1038618447078765&amp;set=a.921728715434406&amp;type=3+MARIO KLOTZ WECHSELT NACH BACKNANG

Mario Klotz wird Chef-Coach der TSG Backnang Fußball. Der bisherige Co-Trainer der Bruchwaldelf wechselt mit sofortiger Wirkung zum Ligakonkurrenten.

Damit vollzieht der ehemalige 08-Spieler einen weiteren Karriereschritt als Trainer. Am Bruchwald hat Klotz als Co-Trainer der U23 begonnen, Trainerlizensierungen durchlaufen und danach das Co-Traineramt der Oberligamannschaft übernommen. Nun folgt der Wechsel auf den Chefposten in Backnang.

&quot;Vielen Dank für die geile Zeit&quot;, mit diesen Worten verabschiedete sich der allseits Klotzer genannte Coach bereits am Mittwoch von der Mannschaft. &quot;Ich denke zurück an unser Trainingslager am Walchsee, an viele starke und unvergessliche Spiele, harte Trainingseinheiten, an Emotionen und die vielen Glücksgefühle, welche wir gemeinsam erleben durften. Das alles und noch vieles mehr bringe ich mit euch in Verbindung&quot;.

Mario Klotz hatte zur Saison 2019/2020 das Co-Trainer Amt bei der U23 der Nullachter übernommen und ist in der Folgesaison als Co-Trainer von Markus Lang bei der Bruchwaldelf eingestiegen. Nun folgt der nächste Schritte mit dem Wechsel als Chef-Trainer zur TSG Backnang.

Der sportliche Leiter des Oberliga-Teams Oliver Dense kommentiert den Wechsel wie folgt: &quot;Mario Klotz ist kurz vor Weihnachten mit der Bitte an uns heran getreten seinen Vertrag aufzulösen, da er Cheftrainer in Backnang werden möchte. Diese Bitte kam für uns sehr überraschend und war vom Zeitpunkt natürlich sehr unglücklich gewählt. Trotzdem wollten wir ihm diese Chance nicht verwehren, da dies auch einen schlüssigen Weg von Mario darstellt und unserem Aufbau der Ausbildung entspricht. So konnten wir uns zügig mit der TSG und Mario auf eine Freigabe einigen.

Eine Nachfolgelösung ist zumindest bis zum Ende der aktuellen Saison in Sicht. &quot;Natürlich war zum jetzigen Zeitpunkt unsere Wunschlösung für einen neuen Co-Trainer in der Kürze der Zeit nicht zu realisieren. Deshalb sind wir sehr froh, dass sich unser Teammanager Mario Di Biccari bereit erklärt hat, diese Rolle übergangsweise bis zum Sommer in Doppelfunktion zu übernehmen. Mario ist als Ex Profi und ehemaliger 08 Spieler eine ideale Lösung, er kennt die Mannschaft das Umfeld und benötigt keine Kennenlernphase. Daher geht unser Dank an Mario Di Biccari für seine Einsatzbereitschaft&quot;, führt Dense weiter aus.

Mario Klotz danken wir für seine Zeit bei Nullacht. Wir verlieren mit ihm einen klasse Typen. Klotzer hat sich immer völlig mit dem Verein identifiziert, hatte stets eine engen Draht zum Team und wird sicherlich ein Stück Nullacht in sich behalten, da er bereits als Spieler bei uns aktiv war. Wir sind uns sicher dass er seinen Weg machen wird, wünschen ihm dafür alles Gute, viel Erfolg und freuen uns stets auf ein Wiedersehen.

Hier geht es zur kompletten Meldung https://fsv08.de/mario-klotz-wechselt-nach-backnang/" target="_blank" rel="noreferrer" class="ft-gallerytwitter-icon" title="Share this post on Twitter"><i class="fa fa-twitter"></i></a><a href="https://plus.google.com/share?url=https://www.facebook.com/photo.php?fbid=1038618447078765&amp;set=a.921728715434406&amp;type=3" target="_blank" rel="noreferrer" class="ft-gallerygoogle-icon" title="Share this post on Google"><i class="fa fa-google-plus"></i></a><a href="https://www.linkedin.com/shareArticle?mini=true&amp;url=https://www.facebook.com/photo.php?fbid=1038618447078765&amp;set=a.921728715434406&amp;type=3" target="_blank" rel="noreferrer" class="ft-gallerylinkedin-icon" title="Share this post on Linkedin"><i class="fa fa-linkedin"></i></a><a href="mailto:?subject=Shared Link&amp;body=https://www.facebook.com/photo.php?fbid=1038618447078765&amp;set=a.921728715434406&amp;type=3 MARIO KLOTZ WECHSELT NACH BACKNANG

Mario Klotz wird Chef-Coach der TSG Backnang Fußball. Der bisherige Co-Trainer der Bruchwaldelf wechselt mit sofortiger Wirkung zum Ligakonkurrenten.

Damit vollzieht der ehemalige 08-Spieler einen weiteren Karriereschritt als Trainer. Am Bruchwald hat Klotz als Co-Trainer der U23 begonnen, Trainerlizensierungen durchlaufen und danach das Co-Traineramt der Oberligamannschaft übernommen. Nun folgt der Wechsel auf den Chefposten in Backnang.

&quot;Vielen Dank für die geile Zeit&quot;, mit diesen Worten verabschiedete sich der allseits Klotzer genannte Coach bereits am Mittwoch von der Mannschaft. &quot;Ich denke zurück an unser Trainingslager am Walchsee, an viele starke und unvergessliche Spiele, harte Trainingseinheiten, an Emotionen und die vielen Glücksgefühle, welche wir gemeinsam erleben durften. Das alles und noch vieles mehr bringe ich mit euch in Verbindung&quot;.

Mario Klotz hatte zur Saison 2019/2020 das Co-Trainer Amt bei der U23 der Nullachter übernommen und ist in der Folgesaison als Co-Trainer von Markus Lang bei der Bruchwaldelf eingestiegen. Nun folgt der nächste Schritte mit dem Wechsel als Chef-Trainer zur TSG Backnang.

Der sportliche Leiter des Oberliga-Teams Oliver Dense kommentiert den Wechsel wie folgt: &quot;Mario Klotz ist kurz vor Weihnachten mit der Bitte an uns heran getreten seinen Vertrag aufzulösen, da er Cheftrainer in Backnang werden möchte. Diese Bitte kam für uns sehr überraschend und war vom Zeitpunkt natürlich sehr unglücklich gewählt. Trotzdem wollten wir ihm diese Chance nicht verwehren, da dies auch einen schlüssigen Weg von Mario darstellt und unserem Aufbau der Ausbildung entspricht. So konnten wir uns zügig mit der TSG und Mario auf eine Freigabe einigen.

Eine Nachfolgelösung ist zumindest bis zum Ende der aktuellen Saison in Sicht. &quot;Natürlich war zum jetzigen Zeitpunkt unsere Wunschlösung für einen neuen Co-Trainer in der Kürze der Zeit nicht zu realisieren. Deshalb sind wir sehr froh, dass sich unser Teammanager Mario Di Biccari bereit erklärt hat, diese Rolle übergangsweise bis zum Sommer in Doppelfunktion zu übernehmen. Mario ist als Ex Profi und ehemaliger 08 Spieler eine ideale Lösung, er kennt die Mannschaft das Umfeld und benötigt keine Kennenlernphase. Daher geht unser Dank an Mario Di Biccari für seine Einsatzbereitschaft&quot;, führt Dense weiter aus.

Mario Klotz danken wir für seine Zeit bei Nullacht. Wir verlieren mit ihm einen klasse Typen. Klotzer hat sich immer völlig mit dem Verein identifiziert, hatte stets eine engen Draht zum Team und wird sicherlich ein Stück Nullacht in sich behalten, da er bereits als Spieler bei uns aktiv war. Wir sind uns sicher dass er seinen Weg machen wird, wünschen ihm dafür alles Gute, viel Erfolg und freuen uns stets auf ein Wiedersehen.

Hier geht es zur kompletten Meldung https://fsv08.de/mario-klotz-wechselt-nach-backnang/" target="_blank" rel="noreferrer" class="ft-galleryemail-icon" title="Share this post in your email"><i class="fa fa-envelope"></i></a></div></div><a href="https://www.facebook.com/photo.php?fbid=1038618447078765&#038;set=a.921728715434406&#038;type=3" target="_blank" rel="noreferrer" class="fts-jal-fb-see-more">  <i class='icon-file'></i> 1 &nbsp;&nbsp;&nbsp;Zeige auf Facebook</a></div><div class="fts-clear"></div></div><div class='fts-fb-photo-post-wrap fts-jal-single-fb-post' ><div  class="fts-jal-fb-right-wrap"><div class="fts-jal-fb-top-wrap "><div class="fts-jal-fb-user-thumb"><a href="https://www.facebook.com/Fsv08Bissingen" target="_blank" rel="noreferrer"><img border="0" alt="FSV 08 Bissingen" src="https://graph.facebook.com/Fsv08Bissingen/picture"/></a></div><span class="fts-jal-fb-user-name"><a href="https://www.facebook.com/Fsv08Bissingen" target="_blank" rel="noreferrer">FSV 08 Bissingen</a> fühlt sich fantastisch.</span><span class="fts-jal-fb-post-time"> </span><div class="fts-clear"></div><div class="fts-jal-fb-message">EINEN GUTEN START INS JAHR 2023⚽️🎉🎊🍀<br />
<br />
Der FSV 08 Bietigheim-Bissingen e.V. wünscht allen einen guten Start ins neue Jahr. 🎉🎊🥳⚽️🍀<br />
Bleibt gesund!<br />
Und an dieser Stelle möchten wir uns auch an alle ehrenamtlichen Helfer*innen bedanken die überhaupt das alltägliche Fußballerlebnis möglich machen. An alle Trainer*innen, Physio, Sportmediziner, Athletiktrainer, Kasse, Betreuer, Ressortleiter, Vorstand, Vereinsheim, Fotografen, Schiedsrichter, alle Eltern und natürlich unsere Zuschauer*innen. <br />
Gemeinsam sind wir ein Team 💪 <br />
🙏 DANKE für euren Support 🙏<br />
<a href="https://www.facebook.com/hashtag/nullachteinteam" target="_blank" rel="noreferrer">#nullachteinteam</a>💙🤍<div class="fts-clear"></div></div></div><div class="fts-jal-fb-link-wrap fts-album-photos-wrap"><a href="https://www.facebook.com/photo.php?fbid=1030834357857174&#038;set=a.921728725434405&#038;type=3" target="_blank" rel="noreferrer" class="fts-jal-fb-picture"><img border="0" alt="FSV 08 Bissingen" src="https://scontent-fra5-2.xx.fbcdn.net/v/t39.30808-6/323428589_658388979409552_1014781521839927952_n.jpg?stp=dst-jpg_p720x720&#038;_nc_cat=109&#038;ccb=1-7&#038;_nc_sid=8bfeb9&#038;_nc_ohc=pou8NnlW7mMAX_sJeJL&#038;_nc_ht=scontent-fra5-2.xx&#038;edm=ALdPpPkEAAAA&#038;oh=00_AfDu5--BxuM3hhkvpw93EzaHobXwQ2WH3BqxK0P7nyHvSw&#038;oe=63D35A2F"/></a><div class="slicker-facebook-album-photoshadow"></div><div class="fts-clear"></div></div><div class="fts-clear"></div></div><div class="fts-likes-shares-etc-wrap"><div class="fts-share-wrap"><a href="javascript:;" class="ft-gallery-link-popup" title="Social Share Options">
<svg viewBox="0 0 24 24" aria-hidden="true" class="svg-inline--fa r-4qtqp9 r-yyyyoo r-50lct3 r-dnmrzs r-bnwqim r-1plcrui r-lrvibr r-1srniue"><g><path d="M17.53 7.47l-5-5c-.293-.293-.768-.293-1.06 0l-5 5c-.294.293-.294.768 0 1.06s.767.294 1.06 0l3.72-3.72V15c0 .414.336.75.75.75s.75-.336.75-.75V4.81l3.72 3.72c.146.147.338.22.53.22s.384-.072.53-.22c.293-.293.293-.767 0-1.06z"></path><path d="M19.708 21.944H4.292C3.028 21.944 2 20.916 2 19.652V14c0-.414.336-.75.75-.75s.75.336.75.75v5.652c0 .437.355.792.792.792h15.416c.437 0 .792-.355.792-.792V14c0-.414.336-.75.75-.75s.75.336.75.75v5.652c0 1.264-1.028 2.292-2.292 2.292z"></path></g></svg></a><div class="ft-gallery-share-wrap"><a href="https://www.facebook.com/sharer/sharer.php?u=https://www.facebook.com/photo.php?fbid=1030834357857174&amp;set=a.921728725434405&amp;type=3" target="_blank" rel="noreferrer" class="ft-galleryfacebook-icon" title="Share this post on Facebook"><i class="fa fa-facebook-square"></i></a><a href="https://twitter.com/intent/tweet?text=https://www.facebook.com/photo.php?fbid=1030834357857174&amp;set=a.921728725434405&amp;type=3+EINEN GUTEN START INS JAHR 2023⚽️🎉🎊🍀

Der FSV 08 Bietigheim-Bissingen e.V. wünscht allen einen guten Start ins neue Jahr. 🎉🎊🥳⚽️🍀
Bleibt gesund!
Und an dieser Stelle möchten wir uns auch an alle ehrenamtlichen Helfer*innen bedanken die überhaupt das alltägliche Fußballerlebnis möglich machen. An alle Trainer*innen, Physio, Sportmediziner, Athletiktrainer, Kasse, Betreuer, Ressortleiter, Vorstand, Vereinsheim, Fotografen, Schiedsrichter, alle Eltern und natürlich unsere Zuschauer*innen. 
Gemeinsam sind wir ein Team 💪 
🙏 DANKE für euren Support 🙏
#nullachteinteam💙🤍" target="_blank" rel="noreferrer" class="ft-gallerytwitter-icon" title="Share this post on Twitter"><i class="fa fa-twitter"></i></a><a href="https://plus.google.com/share?url=https://www.facebook.com/photo.php?fbid=1030834357857174&amp;set=a.921728725434405&amp;type=3" target="_blank" rel="noreferrer" class="ft-gallerygoogle-icon" title="Share this post on Google"><i class="fa fa-google-plus"></i></a><a href="https://www.linkedin.com/shareArticle?mini=true&amp;url=https://www.facebook.com/photo.php?fbid=1030834357857174&amp;set=a.921728725434405&amp;type=3" target="_blank" rel="noreferrer" class="ft-gallerylinkedin-icon" title="Share this post on Linkedin"><i class="fa fa-linkedin"></i></a><a href="mailto:?subject=Shared Link&amp;body=https://www.facebook.com/photo.php?fbid=1030834357857174&amp;set=a.921728725434405&amp;type=3 EINEN GUTEN START INS JAHR 2023⚽️🎉🎊🍀

Der FSV 08 Bietigheim-Bissingen e.V. wünscht allen einen guten Start ins neue Jahr. 🎉🎊🥳⚽️🍀
Bleibt gesund!
Und an dieser Stelle möchten wir uns auch an alle ehrenamtlichen Helfer*innen bedanken die überhaupt das alltägliche Fußballerlebnis möglich machen. An alle Trainer*innen, Physio, Sportmediziner, Athletiktrainer, Kasse, Betreuer, Ressortleiter, Vorstand, Vereinsheim, Fotografen, Schiedsrichter, alle Eltern und natürlich unsere Zuschauer*innen. 
Gemeinsam sind wir ein Team 💪 
🙏 DANKE für euren Support 🙏
#nullachteinteam💙🤍" target="_blank" rel="noreferrer" class="ft-galleryemail-icon" title="Share this post in your email"><i class="fa fa-envelope"></i></a></div></div><a href="https://www.facebook.com/photo.php?fbid=1030834357857174&#038;set=a.921728725434405&#038;type=3" target="_blank" rel="noreferrer" class="fts-jal-fb-see-more">   &nbsp;&nbsp;&nbsp;Zeige auf Facebook</a></div><div class="fts-clear"></div></div><div class='fts-fb-photo-post-wrap fts-jal-single-fb-post' ><div  class="fts-jal-fb-right-wrap"><div class="fts-jal-fb-top-wrap "><div class="fts-jal-fb-user-thumb"><a href="https://www.facebook.com/Fsv08Bissingen" target="_blank" rel="noreferrer"><img border="0" alt="FSV 08 Bissingen" src="https://graph.facebook.com/Fsv08Bissingen/picture"/></a></div><span class="fts-jal-fb-user-name"><a href="https://www.facebook.com/Fsv08Bissingen" target="_blank" rel="noreferrer">FSV 08 Bissingen</a> fühlt sich traurig.</span><span class="fts-jal-fb-post-time"> </span><div class="fts-clear"></div><div class="fts-jal-fb-message">NULLACHT BLEIBT UNVERGESSEN<br />
<br />
Zum Ende des Jahres ist immer auch Abschied abgesagt. Hier ein Interview zum Abschied unseres Vorzeige-Jugendtrainer Robin Docter.<br />
<br />
13 lange Jahre war der fußballbegeisterte Robin Docter Jugendtrainer am Bruchwald, hat hier mit Herzblut und Kompetenz einen herausragenden „Job“ gemacht. Nun steigt der 39-jährige Ex-Stuttgart-Vaihinger, der inzwischen in Sachsenheim wohnt, leider aus. Wir haben den Industriekaufmann interviewt - hier geht es zum Interview <a href="https://fsv08.de/nullacht-bleibt-unvergessen/" target="_blank" rel="noreferrer">https://fsv08.de/nullacht-bleibt-unvergessen/</a><div class="fts-clear"></div></div></div><div class="fts-jal-fb-link-wrap fts-album-photos-wrap"><a href="https://www.facebook.com/photo.php?fbid=1020988078841802&#038;set=a.921728715434406&#038;type=3" target="_blank" rel="noreferrer" class="fts-jal-fb-picture"><img border="0" alt="FSV 08 Bissingen" src="https://scontent-fra5-2.xx.fbcdn.net/v/t39.30808-6/319993705_529421429110271_1119464871812846774_n.jpg?_nc_cat=108&#038;ccb=1-7&#038;_nc_sid=730e14&#038;_nc_ohc=osYHjrcD0joAX87AGLI&#038;_nc_ht=scontent-fra5-2.xx&#038;edm=ALdPpPkEAAAA&#038;oh=00_AfATP2VHv2Ka19sl87xn1pHeOYLJ495p2idYpndawQ0j7w&#038;oe=63D38B7D"/></a><div class="slicker-facebook-album-photoshadow"></div><div class="fts-clear"></div></div><div class="fts-clear"></div></div><div class="fts-likes-shares-etc-wrap"><div class="fts-share-wrap"><a href="javascript:;" class="ft-gallery-link-popup" title="Social Share Options">
<svg viewBox="0 0 24 24" aria-hidden="true" class="svg-inline--fa r-4qtqp9 r-yyyyoo r-50lct3 r-dnmrzs r-bnwqim r-1plcrui r-lrvibr r-1srniue"><g><path d="M17.53 7.47l-5-5c-.293-.293-.768-.293-1.06 0l-5 5c-.294.293-.294.768 0 1.06s.767.294 1.06 0l3.72-3.72V15c0 .414.336.75.75.75s.75-.336.75-.75V4.81l3.72 3.72c.146.147.338.22.53.22s.384-.072.53-.22c.293-.293.293-.767 0-1.06z"></path><path d="M19.708 21.944H4.292C3.028 21.944 2 20.916 2 19.652V14c0-.414.336-.75.75-.75s.75.336.75.75v5.652c0 .437.355.792.792.792h15.416c.437 0 .792-.355.792-.792V14c0-.414.336-.75.75-.75s.75.336.75.75v5.652c0 1.264-1.028 2.292-2.292 2.292z"></path></g></svg></a><div class="ft-gallery-share-wrap"><a href="https://www.facebook.com/sharer/sharer.php?u=https://www.facebook.com/photo.php?fbid=1020988078841802&amp;set=a.921728715434406&amp;type=3" target="_blank" rel="noreferrer" class="ft-galleryfacebook-icon" title="Share this post on Facebook"><i class="fa fa-facebook-square"></i></a><a href="https://twitter.com/intent/tweet?text=https://www.facebook.com/photo.php?fbid=1020988078841802&amp;set=a.921728715434406&amp;type=3+NULLACHT BLEIBT UNVERGESSEN

Zum Ende des Jahres ist immer auch Abschied abgesagt. Hier ein Interview zum Abschied unseres Vorzeige-Jugendtrainer Robin Docter.

13 lange Jahre war der fußballbegeisterte Robin Docter Jugendtrainer am Bruchwald, hat hier mit Herzblut und Kompetenz einen herausragenden „Job“ gemacht. Nun steigt der 39-jährige Ex-Stuttgart-Vaihinger, der inzwischen in Sachsenheim wohnt, leider aus. Wir haben den Industriekaufmann interviewt - hier geht es zum Interview https://fsv08.de/nullacht-bleibt-unvergessen/" target="_blank" rel="noreferrer" class="ft-gallerytwitter-icon" title="Share this post on Twitter"><i class="fa fa-twitter"></i></a><a href="https://plus.google.com/share?url=https://www.facebook.com/photo.php?fbid=1020988078841802&amp;set=a.921728715434406&amp;type=3" target="_blank" rel="noreferrer" class="ft-gallerygoogle-icon" title="Share this post on Google"><i class="fa fa-google-plus"></i></a><a href="https://www.linkedin.com/shareArticle?mini=true&amp;url=https://www.facebook.com/photo.php?fbid=1020988078841802&amp;set=a.921728715434406&amp;type=3" target="_blank" rel="noreferrer" class="ft-gallerylinkedin-icon" title="Share this post on Linkedin"><i class="fa fa-linkedin"></i></a><a href="mailto:?subject=Shared Link&amp;body=https://www.facebook.com/photo.php?fbid=1020988078841802&amp;set=a.921728715434406&amp;type=3 NULLACHT BLEIBT UNVERGESSEN

Zum Ende des Jahres ist immer auch Abschied abgesagt. Hier ein Interview zum Abschied unseres Vorzeige-Jugendtrainer Robin Docter.

13 lange Jahre war der fußballbegeisterte Robin Docter Jugendtrainer am Bruchwald, hat hier mit Herzblut und Kompetenz einen herausragenden „Job“ gemacht. Nun steigt der 39-jährige Ex-Stuttgart-Vaihinger, der inzwischen in Sachsenheim wohnt, leider aus. Wir haben den Industriekaufmann interviewt - hier geht es zum Interview https://fsv08.de/nullacht-bleibt-unvergessen/" target="_blank" rel="noreferrer" class="ft-galleryemail-icon" title="Share this post in your email"><i class="fa fa-envelope"></i></a></div></div><a href="https://www.facebook.com/photo.php?fbid=1020988078841802&#038;set=a.921728715434406&#038;type=3" target="_blank" rel="noreferrer" class="fts-jal-fb-see-more">  <i class='icon-file'></i> 3 &nbsp;&nbsp;&nbsp;Zeige auf Facebook</a></div><div class="fts-clear"></div></div><div class='fts-fb-photo-post-wrap fts-jal-single-fb-post' ><div  class="fts-jal-fb-right-wrap"><div class="fts-jal-fb-top-wrap "><div class="fts-jal-fb-user-thumb"><a href="https://www.facebook.com/Fsv08Bissingen" target="_blank" rel="noreferrer"><img border="0" alt="FSV 08 Bissingen" src="https://graph.facebook.com/Fsv08Bissingen/picture"/></a></div><span class="fts-jal-fb-user-name"><a href="https://www.facebook.com/Fsv08Bissingen" target="_blank" rel="noreferrer">FSV 08 Bissingen</a> fühlt sich erfreut.</span><span class="fts-jal-fb-post-time"> </span><div class="fts-clear"></div><div class="fts-jal-fb-message">ALLES GUTE ZUM GEBURTSTAG STEFFEN <br />
<br />
Steffen Vahldiek feiert heute seinen 6️⃣0️⃣ Geburtstag 🎂🎉🎊<br />
Der FSV 08 Bietigheim-Bissingen e.V. gratuliert deshalb recht herzlich unseren ehemaligen Vorstandsmitglied und langjährigen Freund zum Geburtstag. 🥳<br />
An dieser Stelle möchten wir uns auch für die Unterstützung und Hingabe von Steffen bedanken. <br />
Ohne ihn wäre vieles nicht möglich gewesen.<br />
Deshalb sind wir froh einen einzigartigen Menschen zu haben der ein großes Fußballherz hat für unsere <a href="https://www.facebook.com/hashtag/Bruchwaldelf" target="_blank" rel="noreferrer">#Bruchwaldelf</a>. ⚽️<br />
Auf dich Steffen 🥂<br />
<a href="https://www.facebook.com/hashtag/NullachtEinTeam" target="_blank" rel="noreferrer">#NullachtEinTeam</a> 🤍💙💪<div class="fts-clear"></div></div></div><div class="fts-jal-fb-link-wrap fts-album-photos-wrap"><a href="https://www.facebook.com/photo.php?fbid=1017866905820586&#038;set=a.921728725434405&#038;type=3" target="_blank" rel="noreferrer" class="fts-jal-fb-picture"><img border="0" alt="FSV 08 Bissingen" src="https://scontent-fra5-2.xx.fbcdn.net/v/t39.30808-6/320299660_707920957274690_723985149490747742_n.jpg?stp=cp1_dst-jpg&#038;_nc_cat=101&#038;ccb=1-7&#038;_nc_sid=8bfeb9&#038;_nc_ohc=YtNqXcz__R0AX98v-kY&#038;_nc_ht=scontent-fra5-2.xx&#038;edm=ALdPpPkEAAAA&#038;oh=00_AfCgC8TBEkIXp870AWo0ShrJNx4s81yq4lI_w1nilBe71Q&#038;oe=63D3DBF8"/></a><div class="slicker-facebook-album-photoshadow"></div><div class="fts-clear"></div></div><div class="fts-clear"></div></div><div class="fts-likes-shares-etc-wrap"><div class="fts-share-wrap"><a href="javascript:;" class="ft-gallery-link-popup" title="Social Share Options">
<svg viewBox="0 0 24 24" aria-hidden="true" class="svg-inline--fa r-4qtqp9 r-yyyyoo r-50lct3 r-dnmrzs r-bnwqim r-1plcrui r-lrvibr r-1srniue"><g><path d="M17.53 7.47l-5-5c-.293-.293-.768-.293-1.06 0l-5 5c-.294.293-.294.768 0 1.06s.767.294 1.06 0l3.72-3.72V15c0 .414.336.75.75.75s.75-.336.75-.75V4.81l3.72 3.72c.146.147.338.22.53.22s.384-.072.53-.22c.293-.293.293-.767 0-1.06z"></path><path d="M19.708 21.944H4.292C3.028 21.944 2 20.916 2 19.652V14c0-.414.336-.75.75-.75s.75.336.75.75v5.652c0 .437.355.792.792.792h15.416c.437 0 .792-.355.792-.792V14c0-.414.336-.75.75-.75s.75.336.75.75v5.652c0 1.264-1.028 2.292-2.292 2.292z"></path></g></svg></a><div class="ft-gallery-share-wrap"><a href="https://www.facebook.com/sharer/sharer.php?u=https://www.facebook.com/photo.php?fbid=1017866905820586&amp;set=a.921728725434405&amp;type=3" target="_blank" rel="noreferrer" class="ft-galleryfacebook-icon" title="Share this post on Facebook"><i class="fa fa-facebook-square"></i></a><a href="https://twitter.com/intent/tweet?text=https://www.facebook.com/photo.php?fbid=1017866905820586&amp;set=a.921728725434405&amp;type=3+ALLES GUTE ZUM GEBURTSTAG STEFFEN 

Steffen Vahldiek feiert heute seinen 6️⃣0️⃣ Geburtstag 🎂🎉🎊
Der FSV 08 Bietigheim-Bissingen e.V. gratuliert deshalb recht herzlich unseren ehemaligen Vorstandsmitglied und langjährigen Freund zum Geburtstag. 🥳
An dieser Stelle möchten wir uns auch für die Unterstützung und Hingabe von Steffen bedanken. 
Ohne ihn wäre vieles nicht möglich gewesen.
Deshalb sind wir froh einen einzigartigen Menschen zu haben der ein großes Fußballherz hat für unsere #Bruchwaldelf. ⚽️
Auf dich Steffen 🥂
#NullachtEinTeam 🤍💙💪" target="_blank" rel="noreferrer" class="ft-gallerytwitter-icon" title="Share this post on Twitter"><i class="fa fa-twitter"></i></a><a href="https://plus.google.com/share?url=https://www.facebook.com/photo.php?fbid=1017866905820586&amp;set=a.921728725434405&amp;type=3" target="_blank" rel="noreferrer" class="ft-gallerygoogle-icon" title="Share this post on Google"><i class="fa fa-google-plus"></i></a><a href="https://www.linkedin.com/shareArticle?mini=true&amp;url=https://www.facebook.com/photo.php?fbid=1017866905820586&amp;set=a.921728725434405&amp;type=3" target="_blank" rel="noreferrer" class="ft-gallerylinkedin-icon" title="Share this post on Linkedin"><i class="fa fa-linkedin"></i></a><a href="mailto:?subject=Shared Link&amp;body=https://www.facebook.com/photo.php?fbid=1017866905820586&amp;set=a.921728725434405&amp;type=3 ALLES GUTE ZUM GEBURTSTAG STEFFEN 

Steffen Vahldiek feiert heute seinen 6️⃣0️⃣ Geburtstag 🎂🎉🎊
Der FSV 08 Bietigheim-Bissingen e.V. gratuliert deshalb recht herzlich unseren ehemaligen Vorstandsmitglied und langjährigen Freund zum Geburtstag. 🥳
An dieser Stelle möchten wir uns auch für die Unterstützung und Hingabe von Steffen bedanken. 
Ohne ihn wäre vieles nicht möglich gewesen.
Deshalb sind wir froh einen einzigartigen Menschen zu haben der ein großes Fußballherz hat für unsere #Bruchwaldelf. ⚽️
Auf dich Steffen 🥂
#NullachtEinTeam 🤍💙💪" target="_blank" rel="noreferrer" class="ft-galleryemail-icon" title="Share this post in your email"><i class="fa fa-envelope"></i></a></div></div><a href="https://www.facebook.com/photo.php?fbid=1017866905820586&#038;set=a.921728725434405&#038;type=3" target="_blank" rel="noreferrer" class="fts-jal-fb-see-more">  <i class='icon-file'></i> 1 &nbsp;&nbsp;&nbsp;Zeige auf Facebook</a></div><div class="fts-clear"></div></div></div><div class="fts-clear"></div><div id="fb-root"></div> 